From 9ef8c290d6694588ef2700dcd14527a8ded808ec Mon Sep 17 00:00:00 2001 From: Pedro Knup Date: Mon, 9 Dec 2019 10:29:36 +0100 Subject: [PATCH] feat: updated pymakr docs ensuring the user to install the latest vscode/atom --- content/pymakr/installation/atom.md | 2 +- content/pymakr/installation/vscode.md | 2 +- content/search_index.json | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/content/pymakr/installation/atom.md b/content/pymakr/installation/atom.md index fc5b72e9..5ed8e491 100644 --- a/content/pymakr/installation/atom.md +++ b/content/pymakr/installation/atom.md @@ -10,7 +10,7 @@ For beginners, users getting started with MicroPython & Pycom as well as Atom te Please follow these steps to install the Pymakr Plugin: -1. Ensure that you have Atom installed and open. +1. Ensure that you have the latest Atom installed and open. ![](/gitbook/assets/atom_setup_step_1-1.png) 1. Navigate to the Install page, via `Atom > Preferences > Install` diff --git a/content/pymakr/installation/vscode.md b/content/pymakr/installation/vscode.md index c245263e..096abaf3 100644 --- a/content/pymakr/installation/vscode.md +++ b/content/pymakr/installation/vscode.md @@ -12,7 +12,7 @@ You will also need NodeJS installed on your PC. Please download the latest LTS v Please follow these steps to install the Pymakr VSCode Extension: -1. Ensure that you have VSCode installed and open. +1. Ensure that you have the latest VSCode installed and open. ![](/gitbook/assets/vsc_setup_step_1-1.png) diff --git a/content/search_index.json b/content/search_index.json index a309cd6a..ade284ec 100644 --- a/content/search_index.json +++ b/content/search_index.json @@ -1 +1 @@ -{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["&","api","avail","begin","build","develop","document","exampl","familiaris","featur","feel","free","get","guid","help","info","introduct","jump","module.","product","projects.","pybyt","pycom","pymakr","read","recommend","section","site.","start","started,","straight","through","tool","tutori","variou","welcom","yourself"],"products.html":["##","&","(universal)","(user","3.0","accessori","antenna","batteri","below","bluetooth","board","cabl","case","cat","certain","compat","develop","each","expans","extern","find","fipi","function","functionality.","g01","gpi","illustr","iot","ip67","kit","l01","l01/w01","l04","lipo","lopi","lopy4","lora","lte","m","m1nb","micro","modul","oem","other,","product","products,","products.","pycas","pycom","pyscan","pysens","pysense/pytrack/pyscan","pytrack","refer","requir","sigfox","sipi","supplied)","tabl","univers","usb","utilis","variou","w01","well","wifi","wifi/bt","wipi","✔"],"gettingstarted/introduction.html":["1:","2:","3:","4:","accessori","advertis","antenna","arrow","basic","befor","begin","bottom","button","card","check","chosen","comput","congratul","connect","connected,","cover","decid","decision.","detail","develop","devic","device.","direct","doubt","drivers;","ensur","exampl","excel","explain","familiar","featur","firmwar","first","firstli","get","guid","guide,","hardwar","haven't","highli","instal","interfac","introduct","it.","keen","know","make","modul","module.","module/accessori","navig","need","network","network.","networks.","now","on","order","out","pack","page","page.","part","perform","place","point","product","program","pycom","recommend","regist","registration.","requir","require.","right","second","secondli","set","setup","sim","so,","softwar","stabl","start","step","successfulli","such","take","through","time","up","updat","us","usb","usual","variou","version;","via","wifi.","wireless","you'v"],"gettingstarted/connection/":["adapt","antenna","appropri","base","below","boards,","chapter","connect","connect.","detail","devic","document","each","guide.","hardwar","instruct","modul","module.","need","on","pleas","pycom","select","setup","show","taken","uart","usb","well","wifi"],"gettingstarted/connection/lopy.html":["(locat","(optional)","2.0","2.0exp","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","433mhz.","5.5v","868mhz","915mhz","access","adapterwifilook","align","antenna","antenna.","are:","bands.","basic","befor","better","between","blocked.","board","board,","board.","boots,","both","button","caus","chip","click","come","connect","connection.in","connector","connector.","consumpt","convert","corner","correctly,","creat","credentials:","current","damag","dc","deep","default,","detail","devic","device,","device.","done","down","down.","edg","ensur","even","exp","expans","experi","explan","extern","final","firmli","firmwar","first","firstli","flash","flat","follow","found","ftp","here.","high","hole,","includ","insert","instruct","intend","issu","led).","led.","locat","lock","login","longer","look","lopi","lopy,","lopy.","lopy4.","lopy:","lora","maintain","memori","method","micro","mode","mode.","modul","modules,","more","mount","need","network","newer","next","note:","now","nut.","onc","option","order","otherwis","out","password:","perform","pig","pin","pin.","place","point","possibl","power","products.","provid","put","pycase,","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","recommend","remain","requir","reset","resolv","risk","run","same","screw","server","side","signal","sipy,","sleep","sleep.","sma","software,","ssid:","such","suppli","support","switch","tail","telnet","through","time","toward","tri","u.fl","uart","updat","us","usb","username:","users.","via","vin","visible.","way","well","wifi","wifi/bluetooth","wipi","wlan","www.pycom.io","yourself"],"gettingstarted/connection/lopy4.html":["&","(locat","(lora","(optional)","2.0exp","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","4","433mhz","5.5v","868mhz/915mhz","access","adapterwifilook","align","antenna","antenna.","appropri","are:","band","basic","befor","better","between","blocked.","board","board,","board.","boots,","both","button","chip","click","come","connecor.","connect","connection.in","connector","connector.","corner","correctly,","creat","credentials:","damag","default,","detail","device,","device.","differ","done","down","edg","ensur","exp","expans","extern","final","firmli","firmwar","first","firstli","flat","follow","found","frequenc","ftp","hand","here.","hole,","includ","insert","instruct","intend","led).","led.","left","locat","lock","login","longer","look","lopi","lopy.","lopy4","lopy4,","lopy4.","lopy4:","lora","lora/sigfox","method","micro","modul","modules,","mount","need","network","next","note:","now","nut.","on","onc","only),","option","order","otherwis","out","password:","perform","pig","pin","pin.","place","point","possibl","power","provid","put","pycase,","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","recommend","requir","reset","right","risk","run","same","screw","server","side","sigfox).","signal","sma","software,","ssid:","such","suit","suppli","switch","tail","telnet","through","time","toward","tri","two","u.fl","uart","updat","us","usb","username:","users.","using.","via","vin","visible.","way","well","wifi","wifi/bluetooth","wlan","www.pycom.io","yourself"],"gettingstarted/connection/sipy.html":["(locat","(optional)","2.0","2.0exp","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","5.5v","access","adapterwifilook","align","antenna","antenna.","are:","basic","befor","better","between","blocked.","board","board,","board.","boots,","both","button","caus","chip","click","come","connect","connection.in","connector","connector.","consumpt","convert","corner","correctly,","creat","credentials:","current","damag","dc","deep","default,","detail","devic","device,","device.","done","down","down.","edg","ensur","even","exp","expans","experi","explan","extern","final","fipi","fipy,","firmli","firmwar","first","firstli","flash","flat","follow","found","ftp","here.","high","hole,","includ","insert","instruct","intend","issu","led).","led.","locat","lock","login","longer","look","lopy,","maintain","memori","method","micro","mode","mode.","modul","modules,","more","mount","need","network","newer","next","note:","now","nut.","onc","option","order","otherwis","out","password:","perform","pig","pin","pin.","place","point","possibl","power","products.","provid","put","pycase,","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","recommend","remain","requir","reset","resolv","risk","run","same","screw","server","side","sigfox","signal","sipi","sipy,","sipy.","sipy:","sleep","sleep.","sma","software,","ssid:","such","suppli","switch","tail","telnet","through","time","toward","tri","u.fl","uart","updat","us","usb","username:","users.","via","vin","visible.","way","well","wifi","wifi/bluetooth","wipi","wlan","www.pycom.io","yourself"],"gettingstarted/connection/gpy.html":["(locat","(optional)","2.0exp","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","5.5v","access","acquir","adapterwifilook","antenna","antenna.","are:","basic","befor","best","better","between","blocked.","board","board,","board.","boots,","both","button","card","cat","cellular","click","come","connect","connection.in","connector","connector.","contact","corner","creat","credentials:","damag","default,","detail","device,","device.","done","enabl","exp","expans","extern","firmli","firmwar","first","firstli","follow","found","ftp","gpi","gpy,","gpy.","gpy:","here.","includ","inform","insert","instruct","intend","iot","led).","led.","local","locat","lock","login","longer","look","lte","m1","m1/nb","method","micro","modul","modules,","more","mount","nano","nb","need","network","next","note","note:","now","onc","option","order","otherwis","out","password:","perform","pin","pin.","place","point","possibl","power","provid","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","recommend","regular","requir","reset","risk","run","same","server","side","signal","sim","sim.","software,","special","ssid:gpi","such","suppli","support","switch","telnet","time","toward","tri","u.fl","uart","updat","us","usb","username:","users.","via","vin","visible.","way","well","wifi","wifi/bluetooth","wlan","www.pycom.io","yourself"],"gettingstarted/connection/fipy.html":["(locat","(optional)","2.0exp","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","433mhz.","5.5v","868mhz","915mhz","access","acquir","adapterwifiwhen","align","antenna","antenna.","are:","bands.","basic","befor","best","better","between","blocked.","board","board,","board.","boots,","both","button","card","cat","cellular","click","come","commun","connect","connection.in","connector","connector.","contact","corner","correctly,","creat","credentials:","ct","damag","default,","detail","device,","device.","done","down","edg","enabl","ensur","exp","expans","extern","final","fipi","fipy,","fipy.","fipy:","firmli","firmwar","first","firstli","flat","follow","found","ftp","here.","hole,","includ","inform","insert","instruct","intend","interfer","iot","jumper","led).","led.","local","locat","lock","login","longer","look","lopy4.","lora","lora/sigfox","lte","m1","m1/nb","method","micro","modem.","modul","modules,","more","mount","nano","nb","need","network","next","note","note:","now","nut.","onc","option","order","otherwis","out","password:","perform","pig","pin","pin.","place","point","possibl","power","provid","put","pycase,","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","recommend","regular","remov","requir","reset","risk","rt","run","same","screw","server","side","signal","sim","sim.","sma","software,","special","ssid:","such","suppli","support","switch","tail","telnet","through","time","toward","tri","u.fl","uart","under","updat","us","usb","username:","users.","via","vin","visible.","way","well","wifi","wifi/bluetooth","wlan","www.pycom.io","yourself"],"gettingstarted/connection/wipy.html":["(locat","(optional)","(p12)","2.0","2.0exp","3.0","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","4mb","4mb.","5.5v","512kb","8mb.","access","adapterwifilook","antenna","antenna.","are:","basic","befor","better","between","blocked.","board","board,","board.","boots,","both","button","caus","changes:","chip","click","come","connect","connection.in","connector","connector.","consumpt","convert","corner","creat","credentials:","current","dc","deep","deepsleep","default,","detail","devic","device,","done","down.","even","exp","expans","experi","explan","extern","firmli","firmwar","first","firstli","fix","flash","follow","found","ftp","gpio21","here.","high","includ","insert","instruct","issu","led).","locat","lock","login","longer","look","lopy,","maintain","memori","method","micro","mode","mode.","modul","modules,","more","mount","move","need","network","newer","next","note:","now","onc","option","order","out","password:","perform","pin","pin.","place","point","possibl","power","products.","provid","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","ram","recommend","remain","requir","reset","resolv","run","select","server","signal","sipy,","sleep","sleep.","software,","ssid:","such","suppli","switch","telnet","time","toward","u.fl","uart","updat","upgrad","usb","username:","users.","version","via","vin","visible.","vs","way","well","wifi","wifi/bluetooth","wipi","wipy,","wipy.","wipy:","wlan","www.pycom.io","yourself"],"gettingstarted/installation/":["activ","allow","assist","atom","attempt","autom","befor","code","connectivity.","correctly.","develop","devic","device.","devices:","driver","drivers:","e.g.","easy.","editor","enable.","ensur","environment:","favourit","featur","firmwar","firmware,","free","function","import","instal","make","microsoft","modul","pack","plug","process","product","program","provid","pycom","pymakr","requir","running,","sigfox","simplifi","softwar","stabl","studio","suit","super","text","tool","two","up","updat","upgrad","upload","us","utility:","visual","windows,","year"],"gettingstarted/installation/drivers.html":["(e.g.","(save",".zip","3.0","7,","8/10/+.","`devic","access","ad","adjust","anyth","anyway","back","befor","below.","board","box","brows","can't","check","click","comput","computer)","confirm","contained.","correct,","correctli","devic","devices.","dialout","distribut","done","download","driver","driver.","dropdown","extract","file","file,","first","folder","folder).","folder.","gone","group.","haven't","instal","installed.","instruct","label","link","linux","linux.","maco","make","manag","manager.","menu","navig","need","next","now","offici","open","option","out","permiss","pleas","point","port.","product","publish","pysense/pytrack/pyscan/expans","pytrack/pysens","receiv","recognis","right","search/navig","see","select","serial","shouldn't","softwar","software.","special","specif","specifi","start","successful,","suggest","support","sure","this.","under","updat","us","user","verifi","warn","warning,","window","work","work."],"gettingstarted/installation/firmwaretool.html":["(10.11","(button","(requir","2.0exp","3.0disconnect","ad","appropri","avail","basic","below,","between","board","board,","box","cabl","cable/wir","carefully:","come","comput","computer,","connect","constantli","devic","device.","devices.","dialog","done","download","dure","exp","expans","fail.","featur","firmwar","follow","found","g23","gnd","have","here","here.","higher)","improv","insert","instruct","issues,","jumper","jumpers,","latest","link","linux","loos","maco","make","mode'.","modul","new","now","on","on),","os","package)","pleas","plugin","power","present","previou","procedur","program","put","pymakr","python","readi","reboot","recommend","reconnect","remov","run","rx","screen.","serial","sometim","step","strongli","sure","tool","tool.","transport.","tx","updat","upgrad","upgrading,","upload","us","usb","version","via","window","wire","without","you'r","‘firmwar"],"gettingstarted/installation/pymakr.html":["avail","built","call","develop","easi","editors,","follow","make","platforms:","plugin","popular","possibl","pycom","pymakr","pymakr.","text","two"],"gettingstarted/programming/":["(read","access","allow","alreadi","avail","begin","below.","blink","board","boot","boot:","brows","code","comprehens","computer,","connect","detail","devic","device,","device.","directli","discuss","easiest","easili","enabled,","evalu","exampl","examples:","explain","explor","familiar","familiaris","file","first","follow","free","ftp","ftp:","goe","good","greater","guid","highli","how.","instal","interact","internet","interpreter.","introduct","is,","it.","know","learn","led.","loop)","mani","meant","mechan","micropython","micropython:","modul","module,","module.","network,","new","now","offend","onc","over","page","pages:","physic","platform.","point","possibl","prevent","print","program","programming.","project","project:","pycom","pymakr","pymakr,","python","python,","python.","read","recommend","recov","refer","relat","remov","repl","repl:","requir","rgb","run","safe","script","scripts.","search","server","server,","set","short","simpl","skill","softwar","someth","start","structur","syntax.","take","telnet.","termin","test","those","through","time","together,","tools,","transfer","tutori","tutorials.","type","uart","understand","up","updat","upload","us","variou","veri","via","way","well","wifi","wirelessly.","wish","wrong.","yourself"],"gettingstarted/programming/micropython.html":["&","/flash","3.5","3.5,","3.5.","access","allow","amount.","api","arduino,","automatically:","below.","block","board","board.","boot","boot.pi","booting,","brace","c.","c/c++","class","code","compat","control.","controllers.","definit","denot","design","develop","differences.","documentation.","enforced.","execut","faster","features.","file","firmwar","first","flow","folder","found","ftp","function","hardwar","here","implement","includ","indent","indentation,","indic","intent","introduct","level","librari","line","look","main.py.","major","manag","manner","mean","micro","micropython","micropython,","micropython;","minor","more","much","number","optimis","pictur","place","plugin.","process","provid","pymakr","python","refer","relat","run","same","section","share","similar","simpl","space","specif","specifi","statement","strictli","structur","syntax","taken","those","tip","trick","two","unlik","upward","us","variabl","variat","view","well,","within","work","written","{}"],"gettingstarted/programming/examples.html":["\"","\"!\"","\"hello","\"hello,","#","&","'2604","'bluetooth',","'fipy')","'gpy',","'lopy',","'lte","'sigfox',","'sipy',","'wifi'","'wifi',","'wipy'","('wipy',","(details).","(for","(i.e.","(micropython)","(names)","(regard","(sequence)","(the","+","+=","0","1","10","15","2)","3","3.5,","3.5.","9","9):","=",">","['lora',","add","add(1,","add(number1,","address","address_book","alex!\"","allow","anoth","assign","associ","awar","below","between","block","book","c","case,","cases.","check","code","code.","collect","condit","console.","contact","contain","control","crosswind","cycl","data","declar","def","depend","detail","dictionari","dictionaries,","differ","drive'","drive','chris':'3236","drive','joe':'1301","each","element","elif","equal","etc.","exampl","examples,","examples.","expect","explicitli","featur","find","function","functions/assignments/etc.","goldleaf","high!\")","hillview","his/her","hold","i.e.","immutable,","implement","import","input","instantiation.","items.","key","know","lane'}","language.","less","list","lists,","loop","loop)","loops,","m']","main","manag","mani","manipul","mean","memori","micropython","modifi","more","name","name,","name.","need","network","next","number","number1","number2","number2):","oper","option","order","out","output","over","parameters)","pass","passed.","passes.","person","phrase.","print","print(\"too","print(address_book['alex'])","print(networks[2])","print(pycom_devices[0])","print(variable)","print(welcome_phrase)","print(x)","program","provid","pycom_devic","python","range(0,","range.","refer","referenced.","repeat","result","result.","return","run","sensor","set","show","similar","size","specif","start","statement","store","string","strings,","structur","structures)","syntax,","take","target","target:","temperatur","there'","time","together,","true/false.","tupl","tutorials.","two","until","valu","value).","variabl","variables.","we'v","welcom","welcome(\"alex\")","welcome(name):","welcome_phras","within","world\"","x","y","you.","{'alex':'2604"],"gettingstarted/programming/first-project.html":["\"heartbeat\"","#","(if","(rgb","(so","(you",".pi","1",">",">>>","^","abov","access","add","allow","alt","amount","ap","api","atom","atom,","basis.","beat.","befor","beginn","below","between","blink","blink.","blue","blue.","board","boot.pi","boot.py.","bottom","built","button","button,","button.","c","call","case","case)","chang","check","click","clutter","cmd","code","code,","code.","code:","colour","colours.","come","command","complet","computer.","configur","confirm","connect","contain","control","copi","correctly.","coupl","creat","created,","ctrl","current","default","delays.","depend","detail","detect","devic","device'","device,","device.","directli","directori","directories.","disabl","documentation.","drawbacks.","e.g.","editor","empty,","even","exampl","example,","execut","explan","extra","featur","features,","file","file.","find","firmwar","firmware.","first","first).","first.","firstli","fix","flash","folder","follow","following:","forever.","format","found","ftp","function","global","good","green","guid","haven't","heart","here.","idea","identifi","import","in.","insid","instead","interact","intern","issue.","it'","it,","it.","keyboard.","know","l","larg","led","led.","lib","librari","libraries,","libraries.","load","long","longer","macos,","main","main.pi","make","manag","micropython","modul","module,","module.","more","move","name","need","network","new,","next","notic","now","on","on.","onc","onto","open","open,","options,","order","os","os.mkfs('/flash')","others,","out","over","pane","pane,","pane/bottom","permanently.","persist","point","popul","port","power","press","prevent","previou","previously.","program","project","project).","project,","project.","prompt).","put","pycom","pycom.heartbeat(false)","pycom.rgbled(0x0000ff)","pycom.rgbled(0x00ff00)","pycom.rgbled(0xff0000)","pymakr","pymakr.","pymakr.conf","quick","r","re","reboot","reboots,","red","regular","reload","remain","remov","repl","repl.","respons","return","rgb","run","script","script,","secondly,","section","see","serial","set","settings.","setup","setup,","shown","so:","some_library.pi","specif","split","standard","start","step","stop","structur","structure:","studio","sub","successfulli","such","sync_file_typ","take","telnet","terminal,","test","text","thing","this.","through","time","time.sleep(1)","tree.","true:","turn","two","type","up","upload","upload,","us","usabl","use.","variou","via","visual","want","way","wifi","window","windows,","windows/linux","wish","within","without","won't","work","yet,","|"],"gettingstarted/programming/repl/":["\"safe","access","addit","allow","arrow","auto","b","back.","below","blank","boot\"","boot.pi","both","c","cancel","charact","chunk","code","code.","code:","combinations;","commands.","complet","completion:","connections.","copi","copy/past","ctrl","current","d","d.","devic","devices.","down","e","easiest","echo","enter","evalu","except","execut","exit","explain","f","far","features:","follow","given","goe","halt","histori","history:","includ","input","input,","interact","interrupt","key","line","loop,","main.pi","main.py.","micropython","mode","mode,","mode.","mode'","modul","name","normal","number","out","output:","page","past","perform","perman","press","prevent","print","prompt","pycom","python","raw","read","repl","repl.","reset.","run","script","scroll","see","serial","shortcut","similar","soft","stand","tab","telnet","test","text.","through","up","us","usb","v","variabl","way","write","‘past"],"gettingstarted/programming/repl/serial.html":["$","'devic","'usb","(a","(com","(e.g.","(i.e.","(uart)","/dev/tty.usbmodem*","/dev/ttyusb01","115200","7","\\","\\.","access","add","additionally,","address","allow","alt","associ","atom","below","bind","board","bottom","box","button","click","code.","com","com4)","combin","command","command:","commands:","comput","connect","connected,","convert","copy/writ","creat","ctrl","detail","devic","device'","device.","diagram","directli","down","download","easiest","editor","elev","emul","enter","example,","exit","expans","explan","far","finally,","follow","found","free","get","group","hand","here.","higher","host","increment","inform","instanc","instead","instruct","key","keyboard","left","line","linux","linux,","list","located.","maco","macos,","manager'","menu","methods.","minicom","module).","multipl","name","need","next","obscur","open","open,","option","order","output","over","page","pane","panel","permiss","picocom","platform","plug","port","port)","press","program,","program.","putti","putty.","pycom","pymakr","q","q.","quit","radio","remap","repl","repl,","required),","required.","right","run","screen","screen,","screen.","search","serial","serial,","session","setup","shift","similar","start","studio","sudo)","support","termin","tool","ttyusb.","uart","upon","us","usb","used.","used;","uucp/dialout","via","visual","way","window","windows,","windows.","windows;","~/.screenrc"],"gettingstarted/programming/repl/telnet.html":["$","(23)","(ap)","(e.g.",").","192.168.4.1","192.168.4.1)","192.168.4.1,","above.","access","add","additionally,","address","allow","ap.","appear","are:","atom","authent","authentication.","board","bottom","chang","click","code.","connect","connection,","credenti","date,","default","detail","determin","devic","device'","device.","directli","download","earlier","easiest","editor","emul","enabl","enter","far","featur","final","first","follow","found","free","further","here.","home","host","info","instance,","instance.","instruct","ip","later","leav","linux","local","lopi","machin","maco","micro","mircopython","need","network.serv","network.wlan.","next","offic","onc","open","open,","option","output","over","pane","password","password:","personal,","platform","pleas","plug","point","point,","port","power","program","program,","prompt","putti","putty.","pycom","pymakr","python","re","refer","repl","required.","section","sections.","see","select","server","setup","ssid","still","studio","substitut","support","telnet","telnet,","termin","time","type","upon","us","used.","user","usernam","username:","via","visual","way","wifi","wifi/wlan.","window","windows;","www.pycom.io"],"gettingstarted/programming/ftp.html":["$","(insecure).","/flash","/flash.","192.168.4.1","access","activ","allow","alway","are:","avail","behav","boot","boot.pi","button.","call","card","chang","check","client","client,","clients,","command:","configur","configuration.","connect","correctly.","creat","default","defaults.","devic","device,","device.","document","doesn't","each","encrypt","ensur","example,","extern","file","filezilla","filezilla,","fireftp","flash","follow","ftp","ftp://192.168.4.1","ftp>","gener","immedi","import","in,","inform","information.","instead,","intern","it'","limit","locat","log","macos/linux","macos/linux:","manag","max","maximum","memory.","micro","microsd","mode,","mode.","more","mounted,","nativ","network.serv","new","number","on","one.","open","passiv","password:","plain","pleas","pycom","python","quick","recommend","run","see","serial","server","set","similar","site","small","specif","start","store","support","system","system.","tab,","terminal:","therefore,","time.","to:","transfer","unix","up,","url:","us","username:","via","visit","ways;","well.","windows:","within"],"gettingstarted/programming/safeboot.html":["(i.e.","(not","(updat","1st","2nd","3","3v3",">>>","access","achiev","again.","alreadi","alter","automat","aware,","be","be:","befor","begin","blink","block","boot","boot.pi","bootload","boots.","both","break","button,","card)","certain","clear","code","code,","code.","connect","count).","ctrl+d","cycl","data","delet","devic","device,","device.","disabl","drop","dure","during:","exampl","execut","explain","factori","faster.","file","filesystem","firmwar","firmware,","first,","fix","flash","follow","g23","gain","get","gnd","hard","hardwar","heartbeat","held","high","high,","imag","import","insid","interact","intern","it,","latest","leav","led","level","low","machin","machine.reset()","made","main.pi","main.py.","micropython","mode","mode.","mode;","modul","module.","need","never","next","normal","occur","orang","order","os","os.mkfs('/flash')","ota","output","p12","perform","peripher","persistent,","pin","pin),","possibl","power","press","prevent","previou","previous","problem","proce","procedur","program","put","pycom","pysense/pytrack","reach","receiv","recovered.","releas","remov","repl","repl.","repl:","requir","reset","reset,","resets.","run","run:","safe","same","script,","sd","sec","second","select","set","slowly.","socket","soft","standard","start","state","still","storag","straight","stuck","support","switch","sy","sys.exit()","therefor","time","tool","ty","unaffected.","up","updat","update,","upon","us","via","virtual","wifi/uart","window","wish","within","written","you."],"gettingstarted/registration/":["access","activ","activation;","avail","befor","below","box!","certain","devic","ensur","featur","features.","guid","immedi","list","networking.","out","platform","pleas","pycom","regist","registr","requir","see","setup","specif","such","type","utilis","variou","work"],"gettingstarted/registration/sigfox.html":["#","(not","(which","(you","=","account","account.","activated.","ad","address","alreadi","anymore.","assign","backend","backend,","backend.","befor","before.","binascii","chang","click","command","complet","confirm","copi","correct","countri","coupl","creat","credenti","devic","device'","device),","device).","device.","differ","don't","done,","dure","email","enter","find","firmwar","firmware.","first","go","green","https://backend.sigfox.com/activ","https://backend.sigfox.com/auth/login","id","import","includ","inform","initalis","know","last","latest","login","microchip","navig","need","network","new","now","number","onc","pac","pac.","page","password","print","print(binascii.hexlify(sigfox.id()))","print(binascii.hexlify(sigfox.pac()))","process.","provid","rcz","rcz1","rcz=sigfox.rcz1)","read","receiv","region)","regist","registration,","registration.","repl.","requir","same","screen","see","seen","select","sigfox","sigfox(mode=sigfox.sigfox,","specif","stabl","start,","success","sure","through","transfer","transfer.","updat","updater.","updates.","us","used,","valid","via","want","way"],"gettingstarted/registration/cellular.html":["(for","buy","card","carrier","cat","cellular","check","close","contact","current","deploy","detail","devic","differ","each","example,","find","gpy/fipi","here.","interest","iot.","it'","lab","local","lte","lte.","m1","map","nb","network","networks.","not).","note:","open","order","plan","provid","provider.","recommend","regist","requir","rule","show","sim","special","specif","standard","store,","such","support","surround","them,","trials,","us","whether"],"gettingstarted/registration/lora/":["(abp)","(otaa)","(which","70b3d5499585fca1.","8'))","=","above,","abp","achiev","activ","address,","air","along","applic","awar","below","capabl","code","code:","commun","connect","consid","contribut","desir","detail","devic","device.","directly.","document","each","enabl","encrypt","eui","eui,","exampl","favourit","find","firstli","follow","former","gener","github","guid","hex","ident","identifi","import","instruct","instructions,","key","key.","latter","like:","link","list","lora","lora(mode=lora.lorawan)","lora,","lorawan","method)","modul","need","network","network.","of.","onc","order","otaa","output","over","personalis","pleas","preconfigur","print(ubinascii.hexlify(lora.mac()).upper().decode('utf","prove","provid","pull","pycom","raw","recommend","regist","request.","secret","session","share","specif","string","talk","to,","tutori","ubinascii","unabl","uniqu","us","via","way.","wish","write"],"gettingstarted/registration/lora/ttn.html":["\"i'm","%","%s\"","&","'de","'fffe'","(a","(call","(default:","(e.g.","(must","(ttn)","(ubinascii.hexlify(lora.mac()).decode('ascii')))","+","48","48).","64","64).","868","=","abp","account","account.","act","activ","ad","added,","address","allow","antenna","appear,","applic","application.","applications.","applied,","belong","below","below,","between","binascii","binascii.hexlify(wl.mac())[6:]","binascii.hexlify(wl.mac())[:6]","bit","board","bring","button.","call","chang","click","code","complet","config.py)","configur","configuration:","configured.","connect","console,","correct","countri","creat","create/regist","data","defin","depend","descript","detail","devic","device.","each","email","enabl","enter","eu","eui","eui.","expand","expect","facto'","first","follow","form","forward","forwarder\"","found","frequenc","frequency.","gateway","gateway,","gateway.","gateways.","global","handler","here.","hexadecim","home","id","identifi","import","indoor","insid","know","legaci","locat","lora","lora()","lorawan","mac","match","method","mhz)","modul","nano","navig","need","network","network,","network.","new","next","node","now","number","number,","obtain","on","onc","open.","option","options,","order","otaa","otherwis","outdoor","overview","packet","page","page,","panel,","placement","plan","platform.","pleas","practic","preference.","print(\"deveui:","prior","produc","protocol","protocol.","pycom","recommend","regist","registered,","registr","registration.","requir","retriev","right","router","router.eu.thethings.network).","run","screen","select","semtech","send","server","set","settings.","settings:","setup","showing.","similar","specif","specifi","standard","step","tab","tab.","thing","this,","this.","tick","to.","top","ttn","ttn.","two","ubinascii","udp","under","uniqu","up","us","user","usernam","valu","verifi","way","websit","well","wifi","wl","wlan","wlan()"],"gettingstarted/registration/lora/senet.html":["#","%","%s\"","(abp).","(appeui)","(appkey)","(between","(call","(deveui)","(in","(otaa)","(over","(the","(ubinascii.hexlify(lora.mac()).decode('ascii')))","1.0.x","10","5","64","=","abp","access","account","activ","activated,","activation)","activities.","addit","adr=true,","air","alway","app_eui","app_key","app_key),","appeui","appkey)","appkey.","applic","asia","attempt","australia","auth=(app_eui,","authent","avail","backend","backend).","basi","begin","bit","both","broker","case","cases,","choic","code","come","complet","complete,","configur","connect","consist","creat","custom","datagram","detail","develop","deveui)","devic","device!","device'","device.","device:","docs.","document","dr=0,","dure","each","element","end","environments,","eui","europ","fact","factori","fipi","first","follow","form","formats.","free","gateway","gateway,","gener","global","grant","hexadecim","ident","identifi","identifier.","import","inform","initi","initialis","integrity.","interog","itself","join","key","line","lopi","lopy:","lora","lora()","lora(mode=lora.lorawan,","lora.as923","lora.au915","lora.eu868","lora.init(mode=lora.lorawan,","lora.join(activation=lora.otaa,","lora.mac().to","lora.us915","lorawan","manufactur","match","messag","mode.","narrow","need","network","network.","now","obtain","onboard","onc","oper","optim","otaa","over","paramet","person","pick","pleas","portal","portal,","portal.","present","print(\"deveui:","privaci","process","process.","product","provid","provis","provisioning.","public","public=true)","readi","region","region=lora.us915)","regist","registr","registration.","represent","requir","run","screen.","secret","secur","send","senet","server","server)","servic","session","set","share","sign","socket","standard","start","state","step","stream","support","terminology)","three","through","time","timeout=0)","tutori","two","typic","ubinascii","ubinascii.unhexlify('00112233445566778899aabbccddeeff')","ubinascii.unhexlify('00250c0000010001')","unavailable.","uniqu","unique,","unit","up","us","valu","varieti","veri","walk","want"],"gettingstarted/troubleshooting-guide.html":["$user","&","(1.19.0","(apm","(apm)","(e.g.","(for","(lowercase)","(use",".atom\\packages\\pymakr\\","/","1.","1.0)","1.2.5,","2","2.","2.7:","2.x.","3.","3.0","3.x,","32","64","7.8.0",">>",">>>","access","alloc","alreadi","alway","amount","apm","appear","applic","ask","atom","atom/vscod","back","befor","binascii","binascii.hexlify(machine.unique_id())","bind","bit","board","board,","boot","bootload","button","c","cabl","can't","capit","case","cases,","caus","check","checksum.","code","code,","code.","code:","command","compat","compil","comput","confirm","connect","consol","contain","ctrl","current","depend","detail","develop","devic","dialout","document","doesn't","echo","empti","end","ensur","error","error,","exampl","exit","expans","extens","fail","failed,","file","find","fipi","firmwar","firmware,","folder","folder.","folder:","follow","forum?","g","give","guid","gyp","happen","help","help.","higher)","import","includ","insid","instal","install.","installed.","instead.","issu","latest","lib)","librari","linux","load","locat","look","loop/non","lose","machine,","machines,","make","manag","memory,","memory.","memory'","mode","mode.","modul","module'","name","need","node","nodej","nodejs.","normally,","now","number","nvm","nvm).","occur","old","older","open","oper","os.uname()","packag","package:","permiss","plug","plugin","plugin.","port.","precompil","press","previou","proceeding:","process","project","prompt","provid","put","pycom","pymakr","pymakr@1.0.3)","python","pytrack,","re","reason,","recognis","reinstal","releas","rememb","remov","renam","repl","repl.","reset","result","revert","run","run/sync","safe","save","script","script,","script/program","send","sensor)","separ","serial","serialport","setup","sha1","shields,","similar","solution:","start","stuck","substanti","sudo","support","sure","switch","synchronis","system","system.","system'","take","tell","termin","this,","ticket","time.","traceback","tri","troubleshoot","type","understand","unexpect","uninstal","updat","updater.","upgrad","upgrade.","upload","us","usb","user","usermod","using.","version","versions.","via","vscode","window","within","wrong","you'r","you'r","~/.atom/.apm/pymkr","~/.atom/.apmrc","~/.atom/packages/pymakr","~/.config/atom/cach","—version","‘fail","‘serialport'","“python=/usr/bin/python2.7”","“p”","“x\""],"pymakr/installation/":["avail","built","call","develop","easi","editors,","follow","instal","make","platforms:","plugin","popular","possibl","pycom","pymakr","pymakr.","text","two"],"pymakr/installation/atom.html":["\"connect","&","(the","192.168.4.1","2.0,","3.0",">",">>>,","^","abov","access","additionally,","address","address.","appears.","appli","arrow","atom","atom.","automat","basi","befor","beginners,","between","board","button","button,","button.","cables,","click","click,","clipboard.","comput","configur","connect","consol","copi","correctli","default","desir","devic","don't","download","e.g.","earlier","easiest","edit","editor","ensur","enter","etc.).","expans","extern","few","field","file","finish","firmwar","first","follow","ftdi","g23","get","global","gnd","help","host","indic","instal","installed.","interface.","it!","json","locat","lopi","lower","manually.","messag","micro","micropython","more","name","navig","need","note:","now","offici","open","open.","page,","pane,","password","past","per","pleas","plugin","plugin,","plugin.","plugin:","point","ports.","prefer","press","process","product","project","pycom","pymakr","python,","pytrack/pysens","recommend","remov","reset","respectively.","right","search","second","section","see","select","selected.","serial","set","settings.","show","side","ssid","start","step","steps:","such","sure","take","telnet","telnet.","text","that'","three","time","turn","upgrade,","us","usb","usb\"","usb.","use.","user","usernam","users,","via","well","wifi","window.","wipi","wire","wlan","www.pycom.io.","xxxx,","you'v"],"pymakr/installation/vscode.html":["\"connect","(the","192.168.4.1","5th",">",">>>,","abov","access","additionally,","address","address.","again","appear.","appears,","appears.","appli","arrow","auto","automat","avail","basi","befor","between","board","board,","bottom","button","button.","cables,","click","clipboard.","close","code","code,","code.","command","commands,","comput","configur","connect","connect,","consol","copi","correct","correctli","current","default","desir","detect","devic","device.","download","e.g.","earlier","easiest","edit","ensur","enter","etc.).","expans","extens","extension:","extern","extra","few","field","file","file,","file.","final","finish","firmwar","first","follow","ftdi","g23","global","gnd","host","id","indic","instal","installed.","interface.","it!","it.","json","latest","left","list","lopi","lt","manual","manually.","messag","micro","microsoft'","minutes,","name","navig","need","next","nodej","now","onc","open","open.","page,","password","past","pc.","per","platform","pleas","plugin","plugin,","plugin.","point","port","port.","ports.","press","process","product","project","project.","pycom","pymakr","python,","pytrack/pysens","reload","remov","reset","respectively.","save","search","second","section","see","selected.","serial","set","settings.","show","ssid","step","steps:","studio","such","support","sure","take","telnet","telnet.","that'","three","time","turn","upgrade,","us","usb","usb\"","usb.","use,","use.","usernam","version","via","visual","vs","vscode","vscode.","website.","wifi","window","wipi","wire","within","wlan","www.pycom.io.","xxxx,","you'v"],"pymakr/toolsfeatures.html":["\"/dev/cu.usbseri","\"address\":","\"micro\",","\"password\":","\"python\",","\"scripts\"","\"sync_folder\":","\"username\":","#","&","(current","(read","(repl)","(thi",".pi","ab001234\",","above,","access","addit","address","address/credentials,","adjust","again.","allow","ap","automat","avail","awar","begin","behaviour).","below","below:","blink","blue","board","boot","both","button","button.","call","caught","cert","certif","chang","click","close","code","code,","code.","coding,","colour","colour.","configur","connect","consol","console.","content","control","creat","default","demonstr","desir","devic","device,","device.","directli","directory.","disabl","display","editor'","ensur","enter","evalu","exactli","exampl","example,","exist","exit","featur","feature,","feature.","features.","file","files.","firmwar","folder","folder,","follow","function","functionality.","go","green","happen","here","hex","highest","ignor","import","indent","instance.","interact","known","led","level","lib","librari","light","line","line).","line.","live","local","loop,","loops.","made","main","make","micropython","modul","more","name","need","new","note","now","off/on","on.","one,","onto","open","open)","option","order","out","output","past","perman","place","plugin","point","port","power","pre","press","print","print()","project","projects,","push","pycom","pycom.heartbeat(false)","pycom.rgbled(0x00ff00)","pycom.rgbled(0xff0000)","pymakr","pymakr.conf","pymakr.conf.","python","read.","red","repl","repl.","restart","result","retriev","return","rgb","run","same","save","script","scripts.","see","serial","set","settings.","shown","specif","ssid","standard","start","step","store","structur","structure:","such","support","sync","sync.","take","tell","test","three","time","tool","tools/featur","type","up","upload","upon","us","user","valu","value.","variabl","variable.","variou","version","well","wifi","within","won't","write","written","{","}"],"pymakr/settings.html":["(e.g","(e.g.","(telnet)","/dev/cu.usbseri","1.17.0.b1","192.168.4.1","address","address,","ap","avail","befor","below","blank,","c","caus","click","code","com1","connect","consol","creat","ctrl","ctrl_c_on_connect","current","default","descript","devic","directori","dq0054e","editor","end","extens","featur","file","find","firmwar","higher.","ignor","ignored.","improv","include:","insid","ip","issu","json,","left","linux/macos)","list","log,","lot","micro.","mode","modul","module).","need","open","open_on_start","opened.","other","password","password,","perform","port","procedure.","process.","project","provid","py,","pycom","pymakr","pymakr.","python.","ram","reboot","reliabl","run","safe","safe_boot_on_upload","script","sent","serial","set","signal","specified,","started,","stop","sync","sync_file_typ","sync_fold","synced,","telnet,","telnet.","therefor","to.","tri","true,","txt,","upload","upload.","uploading.","us","user","usernam","username,","variou","version","via","want","window","xml"],"pytrackpysense/introduction.html":["&","(bq24040","(l76","(lis2hh12)","(ltr","(mfrc63002hn)","(mpl3115a2)","(scl).","(sda)","(si7006","(~1ua","01)","3","329al","a20)","acceleromet","addit","altimet","ambient","applic","applications,","asset","axi","barometr","batteri","below","board","board,","boards,","build","card","charger","charger.","chip","connect","connector)","datasheet","datasheets.","deep","detail","devic","digit","each","enabl","environ","expans","featur","find","fulli","function","glonass","gp","gpi08","gpi09","gps,","hardwar","hardware,","here:","humid","i2c","ideal","includ","info","intend","interface.","introduct","iot","jst","l)","light","list","locat","low","microsd","monitoring,","monitoring.","more","nfc","number","offer","oper","p21","p22","pack","pin","power","pressur","pycom","pyscan","pysens","pytrack","quickli","reader","readers.","rfid","rfid/nfc","scan","see","sens","sensing.","sensor","sensor,","sensors.","serial","sleep)","solution!","specif","such","support","temperatur","temperature,","three","track","tracking,","ultra","us","usb","varieti","version","via","whether"],"pytrackpysense/installation/":["added,","addit","be","check","develop","devic","ensur","essenti","featur","features/functionality.","file","firmware,","frequent","github","go","import","includ","instal","librari","pytrack/pysense/pyscan.","repositori","respect","softwar","updat","updated,","week,","well"],"pytrackpysense/installation/firmware.html":["#0","$","(0xf013","(0xf014for","(cdc)","(e.g:","(f013","(f014","(must","(normal","(on","(updat","...","0","0.9","004:","005:","0100","020","04d8","04d8:f013","04d8:f014","0x04d8.","0xef37","0xef38","0xef98","0xef99","0xf011","0xf012","0xf013","0xf014","1","1.","100%","16384","2005","2009","2010","2016","64","7","8","=","?!?","[=========================]","absolut","activ","alloc","allow","alreadi","altern","alway","appear","applic","approxim","apt","arch:","befor","below","below,","below:","board","boot","bootload","both","bottom","brew","bu","bug","button","button)","button.","byte","cabl","capabl","case,","case.","cdc","check","claim","click","com","command","command,","comput","computer.","condit","connect","connector.","console.","continu","copi","copyright","correctly.","d","data","debian:","debug","depict","determin","devic","device...","dfu","dfu,","dfuidle,","directori","directory).","disconnect","done!","done.","doubl","down","download","driver","driver,","driver.","drivers,","each","either:","enter","error","exemple,","expans","f014","fedora:","file","file:","firmwar","first","follow","free","harald","held","here","hold","homebrew:","host","http://sourceforge.net/p/dfu","id","if,","immediately.","inc.","instal","installation:","instructions.","interface...","keep","latest","libusb","libusbk","link","linux","linux:","lsusb","maco","macports:","match","mean","message,\"done!\"","microchip","mistake,","mode","mode)","mode,","mode.","mode:","modes.","navig","need","normal","normal,","note:","on","open","openmoko","output,","pacman","partit","password.","pc","pid),","pleas","plug","port","port,","present","press","procedur","product","program","prompt","prompt.","pyabcde0","pyscan","pysens","pysense),","pysense).","pysense/pytrack/pyscan/expans","pysense_x.x.x.dfu","pytrack","pytrack,","pytrack/pysens","pytrack/pysense,","pytrack:","pytrack_0.0.8.dfu","pytrack_0.0.8.dfu):","releas","repeat","repl","replac","report","requir","required.","reset","return","run","runtim","s1","same","schmidt","schmidt,","second","seconds,","seconds.","see","select","serial","serial:","set","shield","similar","size","softwar","specif","state","state(2)","static.ex","statu","status(0)","status:","stefan","step","steps:","success","successful,","sudo","sudo.","sy","technolog","termin","the“instal","time","tool","tool,","tormod","transfer","ubuntu","unplug","unsuccessful,","up","updat","upload","upon","us","usb","util","util.","util/tickets/","util:","v0.9","v3","v3,","vendor","verifi","version","via","visibl","volden","wait","warning:","warranti","welt","weston","window","x.x.x","yum","zadig","–"],"pytrackpysense/installation/drivers.html":["(e.g.",".zip","3","7","7,","8/10/+,","anyway","back","befor","below","below.","board","box","brows","can't","click","comput","confirm","contained.","correct,","correctli","devic","devices.","download","driver","driver.","drivers.","dropdown","extract","file,","first","folder","folder).","folder.","follow","gone","haven't","instal","installed.","instruct","label","link","linux.","maco","manag","manager.","menu","navig","need","next","now","offici","open","option","out","pleas","point","publish","pysens","pytrack","pytrack/pysens","pytrack/pysense/pyscan/expans","receiv","requir","right","search/navig","see","select","softwar","software.","specifi","start","successful,","suggest","support","under","updat","us","verifi","warn","warning,","well","window","work"],"pytrackpysense/installation/libraries.html":["(lopy,","(pysense/pytrack),",".pi",".zip","/lib","2.0,","=","_lib/pycoproc_","acceleromet","access","add","addit","api.","archive.","be.","behav","below.","board","board.","code","correct","desir","devic","device'","device,","device.","download","enabl","etc.)","exactli","example,","expans","extract","few","file","file,","folder","folder:","follow","found","github","import","importing/us","insid","instal","instruct","latest","librari","libraries,","library.","light","lis2hh12.pi","lt","ltr329als01","ltr329als01(py)","ltr329als01.pi","make","mani","micropython","modul","navig","need","onc","page.","place","plugin,","print(lt.light())","process","process.","py","pycom","pycoproc.pi","pymakr","pysens","pysense()","pysense,","pysense.pi","pysense:","pytrack","read","releas","repositori","required.","resid","run","same","sensor","sensor,","sipy,","specif","standard","to/from","typic","under","upload","upload,","us","used/import","user","utilis","variou","version","via","wipi","wish","written"],"pytrackpysense/apireference/":["abstract","api","away","created,","follow","interact","level","librari","low","next","page","pyscan.","pysense,","pytrack,","refer","respect","sensors.","simplifi","usability,"],"pytrackpysense/apireference/pytrack.html":["'p21')","'p21',","'p22',","(g).","(in","(lis2hh12)","(none,","(quectel","(with","180","180.","3","90","90.","=","acceler","acceleration,","acceleromet","ad","avail","available,","axi","be","beyond","board","board.","chapter","class","construct.","constructor","contribut","coordin","creat","current","debug","degre","describ","design","detail","due","each","exact","expired,","false)","featur","feel","float","found","free","function","github","glonass","glonass)","gnss)","gp","i2c","includ","inform","know","l","l76","l76gnss","l76gnss(pytrack","l76gnss.","l76gnss.coordinates(debug","lack","latitud","latitude.","librari","libraries.","lis2hh12","lis2hh12(pytrack","lis2hh12.","lis2hh12.acceleration()","lis2hh12.pitch()","lis2hh12.roll()","location.","lock","lock.","longitud","longitude/latitude,","make","measurement,","method","more","none)","none).","none,","note","object","object,","onc","orient","output","pass","period","pitch","pleas","possibl","provid","pull","pytrack","pytrack'","pytrack'","rang","read","repeat.","repositori","request","requir","return","roll","roll,","scl","sda","search","seconds)","sensors.","set","speed","successfulli","tilt","time","timeout","true","tupl","valu","variou","verbose.","weekli","well","yaw","yaw."],"pytrackpysense/apireference/pysense.html":["'p21')","'p21',","'p22',","(%)","('c).","(g).","(lis2hh12)","(ltr","(m)","(m).","(mpl3115a2)","(pa),","(pa).","(si7006a20)","01)","180","180.","3","329al","90","90.","=","acceler","acceleration,","acceleromet","ad","addit","als_gain_1x,","als_gain_1x,als_gain_2x,","als_gain_48x,","als_gain_4x,","als_gain_8x,","als_gain_96x","als_int_100,","als_int_150,","als_int_200,","als_int_250,","als_int_300,","als_int_350,","als_int_400","als_int_50,","als_rate_100,","als_rate_1000,","als_rate_200,","als_rate_2000","als_rate_50,","als_rate_500)","als_rate_500,","altimet","altitud","ambient","argument","atmospher","avail","available,","axi","barometr","be","beyond","board","board.","both","chapter","class","construct.","constructor","constructor.","contribut","creat","current","datasheet","degre","describ","design","detail","digit","dual","due","each","exact","extern","featur","feel","float","follow","free","function","gain","gain:","github","humid","humidity.","i2c","includ","inform","integr","integration:","know","lack","level","librari","libraries.","light","lis2hh12","lis2hh12(pysens","lis2hh12.","lis2hh12.acceleration()","lis2hh12.pitch()","lis2hh12.roll()","ltr329als01","ltr329als01(pysens","ltr329als01.light()","lux.","make","measurement,","method","mode","mode:","more","mpl3115a2","mpl3115a2(pysens","mpl3115a2.","mpl3115a2.altitude()","mpl3115a2.pressure()","mpl3115a2.temperature()","none,","note","object","object,","onc","orient","output","pass","percentag","pitch","pleas","possibl","pressur","pressure)","pressure,","provid","pull","pysens","pysense'","rang","rate","rate:","read","rel","repeat.","repositori","request","requir","return","roll","roll,","scl","sda","see","sensor","sensor.","sensors.","si7006a20","si7006a20(pysens","si7006a20.","si7006a20.humidity()","si7006a20.temperature()","successfulli","temperatur","temperature.","tilt","tupl","two","valu","variou","wavelength","weekli","well","yaw","yaw."],"pytrackpysense/apireference/pyscan.html":["'p21')","'p21',","'p22',","(4,","(atqa),","(g).","(lis2hh12)","(ltr","(mfrc6300)","(mfrc630_mf_auth_key_a","0","01)","10),","16","180","180.","3","329al","6","7,","90","90.","=","acceler","acceleration,","acceleromet","accord","activ","ad","als_gain_1x,","als_gain_1x,als_gain_2x,","als_gain_48x,","als_gain_4x,","als_gain_8x,","als_gain_96x","als_int_100,","als_int_150,","als_int_200,","als_int_250,","als_int_300,","als_int_350,","als_int_400","als_int_50,","als_rate_100,","als_rate_1000,","als_rate_200,","als_rate_2000","als_rate_50,","als_rate_500)","als_rate_500,","alway","ambient","answer","answer.","appear","appropri","argument","around","array","array.","authent","authenticated,","authentication.","avail","available,","axi","b","be","beyond","bit","block","block)","block_address","board","board.","both","buffer","buffer.","byte","byte,","call","card","card'","card,","card.","case","chapter","check","checking.","class","collis","command","command.","construct.","constructor","constructor.","contribut","convert","creat","crypto1","current","data","datasheet","debug","debug=false)","degre","describ","design","dest","dest)","detail","determin","devic","device.","digit","disabl","discov","dual","due","each","enabled.","encryption.","error","exact","explain","extern","failure,","failure.","featur","feel","first","float","follow","format","format,","format.","four","free","function","gain","gain:","github","handl","hexadecim","higher","hold","i2c","identifi","idl","includ","inform","initialis","instruction:","integr","integration:","iso14443a,","key","key,","key_typ","key_type,","know","lack","len","len)","length","length)","length.","level","librari","libraries.","light","lis2hh12","lis2hh12(pysens","lis2hh12.","lis2hh12.acceleration()","lis2hh12.pitch()","lis2hh12.roll()","load","long","ltr329als01","ltr329als01(pysens","ltr329als01.light()","lux.","make","manual","measurement,","memori","method","method.","mf","mfrc630","mfrc630(pyscan=none,","mfrc630.format_block(block,","mfrc630.mfrc630_cmd_idle()","mfrc630.mfrc630_cmd_init()","mfrc630.mfrc630_cmd_load_key(key)","mfrc630.mfrc630_cmd_load_key(key).","mfrc630.mfrc630_cmd_reset()","mfrc630.mfrc630_format_block(data,","mfrc630.mfrc630_iso14443a_select(uid)","mfrc630.mfrc630_iso14443a_wupa_reqa(instruction)","mfrc630.mfrc630_mf_auth(uid,","mfrc630.mfrc630_mf_deauth()","mfrc630.mfrc630_mf_read_block(block_address,","mfrc630.mfrc630_print_block(data,","mfrc630.print_debug(msg)","mfrc630_format_block","mfrc630_iso14443_cmd_reqa","mfrc630_iso14443_cmd_wupa,","mfrc630_mf_auth_key_b)","mfrc630_mf_deauth()","mifar","mode.","more","multipl","nfc","none,","nonzero","norm.","note","number","object","object,","object.","occur,","onc","orient","otherwis","output","pass","perform","pitch","pleas","possibl","present,","print","procedur","procedure.","provid","pull","pyscan","pyscan'","pysens","rang","rate","rate:","read","received.","regist","register.","repeat.","repositori","reqa.","request","requir","reset","respons","result","return","roll","roll,","scl","scl='p21',","sda","sda='p22',","see","select","send","sensor","sensors.","separ","set","space","statement","statu","stop","store","succeeded.","success.","successfulli","tilt","timeout","timeout=none,","tri","tupl","two","uid","uid.","uid:","us","valu","variou","wavelength","weekli","well","whether","wrapper","write","wupa","yaw","yaw."],"pytrackpysense/apireference/sleep.html":["\"","#","#from","#pi","(2g)","(accelerometer,","(activ","(class","(express","(inact","(pic","(pin#6","(wakeup)","+","1","2","200)","2000mg","200m","4","5","8","=","abov","acc","acc.enable_activity_interrupt(2000,","acceler","acceleromet","activ","activity/inact","actual","ad","although","and/or","appropri","approxim","are:","asynchron","avail","available,","awoken","be","begin","board","boolean","both","buttom","button)","call","callback","certain","chapter","class,","code","code,","configur","configured.","contribut","default","describ","detect","detection)","display","durat","duration,","duration.","dure","edg","edge.","embed","enabl","event","exampl","example,","executed,","extern","fall","falling])","featur","feel","find","follow","found","free","function","function,","github","go","go_to_sleep()","gp","handler","happen","header)","header).","import","inact","indic","instantiated.","int","interrupt","interrupts,","interv","interval,","interval.","io","it'","last","librari","libraries.","lis2hh12","lis2hh12()","lis2hh12)","manual","maximum","method","method.","methods,","micropython","micropython.","min","minut","mode,","more","next","normal","note","note:","option","out","out.","paramet","pic","pic_rc1","pin","pin#6","pleas","possibl","previous","print(\"approxim","print(\"wakeup","pull","put","py","py.go_to_sleep()","py.setup_int_pin_wake_up(false)","py.setup_int_wake_up(true,","py.setup_sleep(300)","pysens","pysense()","pysense,","pytrack","pytrack()","pytrack.get_sleep_remaining()","pytrack.get_wake_reason()","pytrack.go_to_sleep([gps=true])","pytrack.setup_int_pin_wake_up([rising_edg","pytrack.setup_int_wake_up(rising,","pytrack.setup_sleep(time_seconds)","pytrack.setup_sleep(timout_sec).","pytrack/pysens","quick","ra5).","rc1,","reason","reason.","reason:","remain","remaining:","repositori","request","requir","reset","restart","return","rise","same","script,","sec\")","second","seconds)","seconds.","session","set","set,","setup_sleep()","sleep","sleep.","snippet:","sourc","source,","specifi","start","state","str(py.get_sleep_remaining())","str(py.get_wake_reason()))","threshold","time","time.sleep(0.5)","timeout","toggled.","true)","true])","us","usag","user","valu","variou","wake_reason_acceleromet","wake_reason_int_pin","wake_reason_push_button","wake_reason_tim","wakeup","weekli"],"tutorials/introduction.html":["along","befor","bluetooth,","boards.","code","connect","contain","control","devic","device,","ensur","etc.","exampl","expans","final","firmwar","firmware;","found","gener","i/o","instruct","introduct","later","latest","librari","lopi","lora","modul","network,","network.","node","pin","pycom","pysense.","pytrack","relat","repository.","requir","run","section","see","set","sigfox","sipi","sourc","specif","starting,","such","tutori","tutorials,","up","updates.","us","wifi"],"tutorials/all/":["boards.","contain","devic","exampl","expans","gener","pycom","section","work"],"tutorials/all/repl.html":["\"help()\"","'py'","'pypypypypypypypypypypypypypypypypypypypy'","(power","(putty,","(the","*","+","/","1","10","146","2","2.5","20","2016","21;","3","5","=",">>>",">>>.","above,","above.","appear","appear,","appear:","basic","below.","black","blank","button","charact","command","connect","connecting,","ctrl","cursor.","d","devic","device'","device.","disconnect","end","enter","enter,","esp32","etc).","exampl","example,","fashion.","features:","first","flash","following,","g1d8b5e5","goe","hard","hardwar","hello","here","i.e.","ident","import","indic","information.","isn't","led","led(0)","led(1)","led).","led.toggle()","let'","lopi","lopy!","lopy!\")","machin","make","message,","methods.","micropython","mode=pin.out,","more","next","obligatori","off/on)","onc","open","out","output","perform","picocom,","pin","pin('g16',","place","plugin,","press","print(\"hello","program","prompt","prompt,","prompt.","pyb:","pycom","pymakr","python","reboot","repl","reset","reset.","reset;","rgb","rst","screen","screen,","see","serial","session,","similar","small","soft","someth","still","sure","switch","telnet,","termin","test","test:","text","tri","two","type","typed.","upon","us","utilis","v1.4.6","value=1)","work","working,","wrong,"],"tutorials/all/wlan.html":["!=","\"+net_to_use+\"","#","&","'',","'':","''},","'10.0.0.1')},","'10.0.0.1',","'192.168.178.1',","'255.255.0.0',","'255.255.255.0',","'8.8.8.8'))","'mywifi':","'mywifikey'),","'password'),","'username',","'wlan_config'","'wlan_config':","('10.0.0.114',","(chain)","(ip,","(or","(sec,","(wlan.ap","+","/flash/boot.py:","/flash/cert.","115200)","=","==",">>>","[e.sec","address","address,","address:\"","alway","antenna=wlan.int_ant)","ap","appropri","around","assign","auth=(net.sec,","auth=(wlan.wpa2,","auth=(wlan.wpa2_ent,","auth=(wlan.wpa2_ent,),","auth=original_auth,","automat","available_net","available_nets])","befor","below","below,","boot","boot.pi","break","broken.","ca","ca_certs='/flash/cert/ca.pem')","ca_certs='/flash/cert/ca.pem',","call","case","caus","certfile='/flash/cert/client.crt')","certif","chang","channel=6,","check","class","client","code","command","configur","connect","connecting,","connection.","constructor","copi","crucial","current","default.","devic","device,","devices,","dns_server)","duplic","dure","e","e.g.","e.ssid","e:","eap","enabl","enterpris","except","execut","exist","featur","file","fix","follow","found!')","frozenset([e.ssid","frozenset([key","gateway,","get","go","hold","home","identity='myidentity',","import","instance,","instruct","interact","ip","key","key,","keyfile='/flash/cert/client.key',","known","known_net","known_nets[net_to_use]","known_nets])","known_nets_nam","known_nets_names)","line","list","list(net","locat","lopi","machin","machine.idle()","machine.reset_cause()","machine.soft_reset:","machine.uart(0,","match","mean","mode","mode\")","mode,","mode;","multipl","necessary,","net","net.ssid","net_properti","net_properties:","net_properties['pwd']","net_to_us","net_to_use[0]","net_to_use][0]","nets\")","nets:","network","network,","networks:","notic","now","object,","obtain","option","order","original_auth","original_ssid","os","os.dupterm(uart)","over","pair.","param","password","peap","power","print(\"connect","print(\"fail","print(\"scan","print('network","print('wlan","privat","proce","provided.","public","put","pwd","pwd),","pycom","repl","requir","reset","reset.","retriev","router","run","run:","running:","save","scan","script","sec","secur","serial","server'","session","set","settings!!","setup","soft","ssid,","ssid=original_ssid,","static","station:","status,","subnet_mask,","succeeded!')","system","telnet","therefor","this:","timeout=10000)","timeout=5000)","tls:","try:","ttls),","ttls:","two","uart","uart.","under","up","up)","up,","upon","us","usb.","user","usernam","valid","via","wait","way","wifi","wifi.","without","wl","wl.auth()","wl.connect(net_to_use,","wl.ifconfig()[0])","wl.ifconfig(config=net_properties['wlan_config'])","wl.init(mode=wlan.ap,","wl.isconnected():","wl.mode(wlan.sta)","wl.scan()","wl.ssid()","wlan","wlan()","wlan(mode=wlan.sta)","wlan.ap","wlan.connect('mywifi',","wlan.connect(net.ssid,","wlan.connect(ssid='mywifi',","wlan.ifconfig(config=('192.168.178.107',","wlan.init(mode=wlan.sta)","wlan.isconnected():","wlan.mode()","wlan.scan()","wlan_config","wpa2","{","{'pwd':","}"],"tutorials/all/ble.html":["#","%","%x'","&","'heart","(apple'","(char.properties()","1)","10","=","==","addr","adv","adv:","advertis","advertisements.","advertiser.","again","api","around","attempt","available.","basic","ble","bluetooth","bluetooth()","bluetooth.adv_manufacturer_data)","bluetooth.adv_name_cmpl)","bluetooth.adv_name_cmpl))","bluetooth.connect(adv.mac)","bluetooth.get_adv()","bluetooth.isscanning():","bluetooth.prop_read):","bluetooth.resolve_adv_data(adv.data,","bluetooth.start_scan(","bluetooth.start_scan(10)","bluetooth.start_scan(20)","bluetooth.stop_scan()","break","bt","bt.connect(adv.mac)","bt.get_adv()","bt.resolve_adv_data(adv.data,","bt.start_scan(","bytes:","call","char","char.read()))","chars:","complet","conn","conn.disconnect()","conn.services()","connect","continu","data","devic","device.","else:","exampl","except:","featur","features.","firmwar","found","full","function","future,","here)","ibeacon","implement","import","indefinit","info","it'","line","manufactur","mfg_data","mfg_data:","more","name","near","network","none","page","pairing.","pass","present,","print","print(\"connect","print('char","print('read","print(bluetooth.get_adv())","print(bluetooth.resolve_adv_data(adv.data,","print(ubinascii.hexlify(mfg_data))","quick","rang","rate'","rate':","raw","receiv","reference.","resolve_adv_data()","retriev","scan","second","send","sent","servic","service.characteristics()","service.uuid())","services.","services:","start","stop","such","time","time.sleep(0.050)","timeout","tri","true:","try:","type(service.uuid())","ubinascii","until","updat","us","usag","valu","within","{}","{}\".format(ubinascii.hexlify(adv.mac)))","{}'.format(char.uuid(),","{}'.format(service.uuid()))"],"tutorials/all/https.html":["/flash/cert/","1])","443)[0][","8441)[0][","=","api","basic","below","blynk","ca_certs='/flash/cert/ca.pem')","cert_reqs=ssl.cert_required,","certif","check","cloud.","connect","device.","download","exampl","folder","http","import","info,","modul","more","place","reference.","s","socket","socket.socket()","ss","ss.connect(socket.getaddrinfo('cloud.blynk.cc',","ss.connect(socket.getaddrinfo('www.google.com',","ssl","ssl.wrap_socket().","ssl.wrap_socket(s)","ssl.wrap_socket(s,","us"],"tutorials/all/mqtt.html":["\"io.adafruit.com\",user=\"your_username\",","\"wifipassword\"),","=","account.","adafruit","adafruit'","allow","api","auth=(wlan.wpa2,","broker","broker.","client","client.check_msg()","client.connect()","client.publish(topic=\"youraccount/feeds/lights\",","client.set_callback(sub_cb)","client.subscribe(topic=\"youraccount/feeds/lights\")","creat","credentials.","data","def","devic","exampl","free","functionality.","guid","hold","ideal","import","inform","io","iot","key","lightweight","machin","machine.idle()","messag","more","mqtt","mqtt.","mqttclient","mqttclient(\"device_id\",","msg):","msg=\"off\")","msg=\"on\")","need","network","off\")","on\")","order","packet","password=\"your_api_key\",","platform,","port=1883)","print(\"connect","print(\"send","print(msg)","protocol","same","send","show","small","sub_cb(topic,","subscrib","time","time.sleep(1)","timeout=5000)","tinker","topic","topic,","true:","us","via","visit","well","wifi.","wifi\\n\")","wlan","wlan(mode=wlan.sta)","wlan.connect(\"yourwifinetwork\",","wlan.isconnected():","you'll"],"tutorials/all/aws.html":["\"","\")","\"accepted\":","\"deltalistener\"","\"mi","\"rejected\":","\"shadowecho\"","\"shadowupdater\"","\"timeout\":","#","#################","##################","#######################","########################","#client_id","#conn_disconn_timeout","#connect","#mqtt_oper_timeout","#thing_nam","'/flash/cert/aws_client.cert'","'/flash/cert/aws_private.key'","'/flash/cert/aws_root.ca'","'aws_host_url'","'my_wifi_password'","'my_wifi_ssid'","'publishtopic'","'pycompublishclient'","'to","'{\"state\":{\"desired\":{\"property\":'","'}}}'","(*.pem.crt)","(*.private.pem.key)","(amazon","(config.py):","(main.py)","(pycom","+","+=","/","/flash/cert","0","1","1)","1,","10","2","5","5)","8883","=","==","\\n\\n\")","accepted!\")","action","activ","all:","amazon","applic","attach","authorise.","aw","aws_client_cert","aws_host","aws_port","aws_private_key","aws_root_ca","awsiotmqttclient(config.client_id)","awsiotmqttshadowclient(config.client_id)","broker","button","button,","buttons.","ca","callback","certif","certificate,","certificates,","choos","click","client","client.","client_id","cloud","code","collect","common","config","config.aws_client_cert)","config.aws_port)","config.aws_private_key,","config.last_will_msg,","config.pi","configur","conn_disconn_timeout","connect","consol","contain","control","creat","custom","customcallback(client,","customcallback)","customshadowcallback_delete(payload,","customshadowcallback_delta(payload,","customshadowcallback_update(payload,","customshadowcallback_update,","def","delet","delta","detail","devic","device):","deviceshadowhandl","deviceshadowhandler.shadowdelete(customshadowcallback_delete,","deviceshadowhandler.shadowregisterdeltacallback(customshadowcallback_delta)","deviceshadowhandler.shadowupdate(jsonpayload,","diagram","doc","dot","download","draining_freq","echo","enabl","enter","file","file.","flash","folder.","forev","format,","ftp","function","gener","get","github","give","go","hand","host","imag","inform","interact","internet","iot","json","json.loads(payload)","jsonpayload","key","last","last_will_msg","last_will_top","latest","left","let","link","listen","loop","loopcount","main.pi","manag","messag","message'","message):","message:","messages,","more","mqtt","mqtt_oper_timeout","name","name\"","navig","need","new","offline_queue_s","out!\")","page,","pane,","path","paths.","payloaddict","pdf","platform","polici","press","print(\"","print(\"delet","print(\"from","print(\"property:","print(\"receiv","print(\"upd","print(\"version:","print('aw","print(message.payload)","print(message.topic)","privat","process","publish","put","pycom","pycomawsmqttcli","pycomawsmqttclient.configureconnectdisconnecttimeout(config.conn_disconn_timeout)","pycomawsmqttclient.configurecredentials(config.aws_root_ca,","pycomawsmqttclient.configuredrainingfrequency(config.draining_freq)","pycomawsmqttclient.configureendpoint(config.aws_host,","pycomawsmqttclient.configurelastwill(config.last_will_topic,","pycomawsmqttclient.configuremqttoperationtimeout(config.mqtt_oper_timeout)","pycomawsmqttclient.configureofflinepublishqueueing(config.offline_queue_size)","pycomawsmqttclient.connect():","pycomawsmqttclient.subscribe(config.topic,","pycomawsmqttshadowcli","pycomawsmqttshadowclient.configureconnectdisconnecttimeout(config.conn_disconn_timeout)","pycomawsmqttshadowclient.configurecredentials(config.aws_root_ca,","pycomawsmqttshadowclient.configureendpoint(config.aws_host,","pycomawsmqttshadowclient.configuremqttoperationtimeout(config.mqtt_oper_timeout)","pycomawsmqttshadowclient.connect():","pycomawsmqttshadowclient.createshadowhandlerwithname(config.thing_name,","register/manag","rejected!\")","remotely.","report","repository.","request","responsestatu","responsestatus,","root","sampl","secur","see","send","set","settings,","shadow","shown","side,","sign","specif","specifi","start","state","str(loopcount)","str(payloaddict[\"state\"][\"desired\"][\"property\"]))","str(payloaddict[\"state\"][\"property\"]))","str(payloaddict[\"version\"]))","subscib","subscrib","succeeded')","telemetri","thing","things.","three","time","time.sleep(1)","time.sleep(2)","time.sleep(5)","token","token):","token:","topic","topic:","topics.","true)","true:","up","updat","user","user.","userdata,","via","website):","wifi","wifi,","wifi_pass","wifi_ssid"],"tutorials/all/adc.html":["#","1.1v","1120.","=","abov","access","accur","adc","adc()","adc(0)","adc.","adc.channel(pin='p13')","adc.channel(pin='p16',","adc.vref(1100)","adc.vref_to_pin('p22')","adc_c","adc_c()","adc_c.value()","attn=adc.attn_11db)","calibr","check","code","connect","current","disconnect","down","e.g.","each","esp32'","exampl","extern","factory.","firstli","follow","import","inform","intern","it.","known","machin","mean","measur","millivolts,","module.","more","note","now","output","p22","pleas","print(adc_c.voltage())","read","refer","reference.","reset","sample.","see","set","simpl","source.","tell","time","to.","true","us","valu","voltag","voltmet","vref","wish"],"tutorials/all/i2c.html":["\"!bb\"","\"!bh\"","#","(((data[0]","(device_id","(len","(recv_data)","(wait","+=","0","0):","0.1","1","120m","2)","2):","200):","5","=","==",">",">=","__init__(self,","ad","addr","addr=0x23,","addr=i2c.scan()[0])","anoth","baudrate=100000)","bh1750fvi","bh1750fvi.bh1750fvi(i2c,","bh1750fvi.py.","bh1750fvi:","bytes([0x10]))","class","code","code,","connectivity,","const(120)","continuo","data","def","device.","device_id","device_id,","digit","driver","enabl","exampl","file","follow","i2c","i2c(0,","i2c,","i2c.","i2c.master,","import","library.","light","light_sensor","light_sensor.read()","light_sensor.read())","lora","lora(mode=lora.lora,","lora_confirm_format","lora_pkg_format","lora_sock","lora_sock.recv(64)","lora_sock.send(msg)","lora_sock.setblocking(false)","lux","machin","measurement_tim","measurement_time:","msg","name","network","period","period=150):","place","print(data)","pycom","pycom.heartbeat(false)","pycom.rgbled(0x001500)","pycom.rgbled(0x150000)","read","read(self):","receiv","recv_data","recv_data)","region=lora.eu868)","same","sampl","self.addr","self.i2c","self.i2c.readfrom(self.addr,","self.i2c.writeto(addr,","self.period","self.tim","self.valu","send","sensor","sensor.","simpl","socket","socket.sock_raw)","socket.socket(socket.af_lora,","start","statu","status,","struct","struct.pack(lora_pkg_format,","struct.unpack(lora_confirm_format,","time","time.sleep(0.1)","time.sleep(1)","tx_iq=true,","us","valu","wait","while(true):"],"tutorials/all/owd.html":["\"\"\"","#","#!/usr/bin/env","&","((l_rom[byte]","((~temp_read","(1","(8","(count_per_c","(crc","(temp_msb","*","+","+=","//","0","0:","0x01","0x01:","0x18","0x28:","0x7f","0x80","0xff)","1","1)","1.","100","25","64","65","8","=","==",">",">=",">>","[]","[rom]","^","__init__(self,","_search_rom(self,","assert","attach","avail","b","b:","basic","bit","break","bu","buf):","buf:","byte","byte)","bytearray","bytearray(8)","bytes).","bytes.","class","cmd_matchrom","cmd_readrom","cmd_searchrom","cmd_skiprom","collision,","complement","comput","connect","const(0x33)","const(0x55)","const(0xcc)","const(0xf0)","convert","count_per_c","count_remain","count_remain)","crc","crc8(self,","data","data):","data[6]","data[7]","data[i]","def","devic","devices.","diff","diff)","diff):","differ","disable_irq","disable_irq()","don't","driver","ds18b20","ds18x20","ds18x20(ow)","each","elif","else:","enable_irq","enable_irq(i)","error","explain","fals","fb_bit","fill","function.","github","half","high","import","l_rom","l_rom,","l_rom:","librari","line","list","machin","machine.disable_irq","machine.disable_irq()","machine.enable_irq","match","mean","micropython","next_diff","none,","now","object","onewir","onewire(pin('p10'))","onewire:","otherwise.","ow","p10","pass","perform","pin","pin()","pin(0)","pin(1)","pin):","pin.pull_up)","presenc","print(temp.read_temp_async())","pulse,","pycom","python3","r_b","range(0xff):","range(8):","range(len(data)):","read","read_bit(self):","read_byte(self):","repository.","reset","reset(self):","return","rom","rom):","rom,","rom0","rom:","scan(self):","select","select_rom(self,","self._search_rom(rom,","self.pin","self.pin.init(pin.open_drain,","self.read_bit()","self.read_bit():","self.reset()","self.reset():","self.write_byte(b)","self.write_byte(cmd_matchrom)","self.write_byte(cmd_searchrom)","self.write_bytes(rom)","sensor.","shift","shifting,","sleep_u","sleep_us(1)","sleep_us(40)","sleep_us(420)","sleep_us(480)","sleep_us(60)","specif","statu","talk","temp","temp.start_conversion()","temp_lsb","temp_read","temperatur","time","time.sleep(1)","time.sleep_u","to.","true","true:","truncat","tutori","two","two'","usag","valu","without","write_bytes(self,","|","|="],"tutorials/all/threading.html":["%","%d'","(i","+","1,","3","=","_thread","_thread.allocate_lock()","_thread.start_new_thread(th_func,","a_lock","a_lock:","below","def","defin","demonstr","differ","each","exampl","executes\")","follow","function","i))","id)","id):","import","interval.","lock","locks:","micropython","module.","number","on","parameters.","perform","print","print(\"a_lock","print('run","range(3):","receiv","simpli","spawn","started,","support","th_func(delay,","thread","time","time.sleep(delay)","true:","us"],"tutorials/all/rgbled.html":["#","10","4s","alive.","blue","code","colour","cycl","cycles.","default","detected.","error","expect","flash","follow","green","heartbeat","here","import","indic","led","light","make","module.","onc","overridden","piec","pycom","pycom.heartbeat(false)","pycom.rgbled(0x007f00)","pycom.rgbled(0x7f0000)","pycom.rgbled(0x7f7f00)","pycom.rgbled(0xff00)","range(10):","red","result:","rgb","run","signal","stop","system","through","time","time.sleep(1.5)","time.sleep(4)","time.sleep(5)","traffic","turn","us","yellow"],"tutorials/all/timers.html":["#","%","%f","(total","+=","0","1","1,","1.25","10","10:","=","==","__init__(self):","_seconds_handler(self,","alarm","alarm):","alarm.callback(none)","block","callback","chrono","chrono.read()","chrono.start()","chrono.stop()","chronomet","class","clock","clock()","clock:","code","code.","count","def","detail","done","elaps","even","exampl","example,","execut","finish","first","follow","found","good","handl","handling.","however,","import","inform","interrupt","interrupt.","interval.","it'","keep","lap","lap\"","lap)","lap))","last","machin","measur","mind","more","much","network","passed\"","periodic=true)","possibl","practic","print(\"","print(\"%02d","print(\"\\nth","print()","race\"","racer","read","request","restrict","second","seconds.","self.__alarm","self.second","self.seconds)","sequentially,","short.","simpl","simul","specif","stop","stopwatch.","time","time.sleep(1.25)","time.sleep(1.5)","timer","timer.","timer.alarm(self._seconds_handler,","timer.chrono()","took","total","total)","us","without"],"tutorials/all/pir.html":["!=","\")[1]","\"+net_to_use+\"","\"+self.basic+\"\\r\\n\\r\\n\")","\"+str(return_code))","#","#config","#flag","&","'',","'10.0.0.1')},","'10.0.0.1',","'255.255.0.0',","'networkid':","'utf8')","'wlan_config'","'wlan_config':","('10.0.0.8',","(boot.py)","(configur","(domoticz.py)","(main.py)","(sec,","+",",\"\")","/json.htm?\"+path+\"","0","10","115200)","1:","8080","=","==",">","[e.sec","__init__(self,","address:\"","antenna=wlan.int_ant)","ap","auth=original_auth,","available_net","available_nets])","basic","basic):","boot","case","channel=6,","class","code","command):","connect","constantli","d","d.setvariable('presence:livingroom','1')","def","detected,","domoticz","domoticz(\"\",","domoticz:","e","e.ssid","e:","else:","except","exception:","failed\")","frozenset([e.ssid","frozenset([key","go","high,","hold_tim","hold_time_sec","hold_time_sec:","http","http/1.1\\r\\nhost:","idx,","import","installation.","ip","ip,","keep","key","known","known_net","known_nets[net_to_use]","known_nets])","known_nets_nam","known_nets_names)","last_trigg","list(net","loop","loop\")","machin","machine.idle()","machine.reset_cause()","machine.soft_reset:","machine.uart(0,","main","mode\")","more","motion","name,","net","net_properti","net_properties:","net_properties['pwd']","net_to_us","net_to_use[0]","net_to_use][0]","nets\")","network","network,","original_auth","original_ssid","os","os.dupterm(uart)","path):","pin","pin('g4',mode=pin.in,","pir","pir()","port","port,","power","presence\")","print(\"connect","print(\"exit","print(\"fail","print(\"http","print(\"no","print(\"pres","print(\"request","print(\"scan","print(\"start","print(e)","pull=pin.pull_up)","pwd","pwd),","pycom.io\\r\\nauthorization:","read","request","request\")","result:","return","return_cod","s","s.close()","s.connect((self.ip,self.port))","s.send(b\"get","save","scripts,","sec","second","see","self.bas","self.ip","self.port","self.sendrequest(\"type=command¶m=switchlight&idx=\"+idx+\"&switchcmd=\"+command)","self.sendrequest(\"type=command¶m=updateuservariable&vtype=0&vname=\"+name+\"&vvalue=\"+value)","send","sendrequest(self,","sensor","setlight(self,","setvariable(self,","simpl","socket","socket.socket()","ssid=original_ssid,","statu","status.split(\"","step","str(s.readline(),","time","time.sleep_ms(500)","time.time()","timeout=10000)","trigger","trigger,","true:","try:","tutorial.","uart","value):","variable).","wait","wifi","wl","wl.auth()","wl.connect(net_to_use,","wl.ifconfig()[0])","wl.ifconfig(config=net_properties['wlan_config'])","wl.init(mode=wlan.ap,","wl.isconnected():","wl.mode(wlan.sta)","wl.scan()","wl.ssid()","wlan","wlan()","wlan(wlan.sta)","wrapper","{","{'pwd':","}"],"tutorials/all/modbus.html":["'","'.join('{:d}'.format(x)","'failure'","'success'","(modbu","(on/off)","+","/flash.","0","0.","0x00,","0x0000","0x01","0x02","0x03","0x04","0x05","0x06","0x0f","0x10","0xff00","1024]","125","2000","256,","32768","4,","6,","=","action","address","address,","analog","analogu","architecture.","array","avail","below.","between","code","codes.","coil","coil_quantity)","coil_quantity=100","coil_statu","coil_status))","coils,","command","commands,","commonli","commun","connect","content","contigu","continu","data","defin","deliv","descript","devic","device,","device.","discret","file.","first","folder","follow","found","ftp","function","github","here.","hold","independ","inform","input","input,","input_quantity)","input_quantity=100","input_statu","input_status))","intend","kind","librari","library,","list","master/slav","maximum","mean","medium","messag","modbu","modbus_obj.read_coils(slave_addr,","modbus_obj.read_discrete_inputs(slave_addr,","modbus_obj.read_holding_registers(slave_addr,","modbus_obj.read_input_registers(slave_addr,","modbus_obj.write_multiple_coils(slave_addr,","modbus_obj.write_multiple_registers(slave_addr,","modbus_obj.write_single_coil(slave_addr,","modbus_obj.write_single_register(slave_addr,","more","multipl","name","number","off.","on,","output","output_address,","output_address=0x00","output_flag","output_flag)","output_value)","output_value=0xff00","output_values)","output_values=[1,1,1,0,0,1,1,1,0,0,1,1,1]","over","packet","pdf","perform.","print('coil","print('hold","print('input","print('writ","protocol","pycom","python","quantiti","read","read.","regist","register_address,","register_address=0x01","register_quantity,","register_quantity=100","register_valu","register_value))","register_value,","register_value=","register_values,","register_values=[2,","registers.","remot","repository.","request","request.","request/repli","return_flag","rtu","rtu).","sampl","see","sequenc","serial","servic","set","shown","sign","signatur","signed)","signed=tru","singl","slave","slave_addr=0x0a","specifi","specified.","start","starting_address,","starting_address=0x0","starting_address=0x00","state","statu","status:","structur","support","target","tcp","tcp)","tell","transfer","transmiss","transmit","umodbu","up","upload","us","usual","valu","value,","value:","values,","via","write","written.","x"],"tutorials/all/ota.html":["\"1.0.1b\"","\"1095df8213aac2983efd68dba9420c8efc9c7c4a\"","\"ccc6914a457eb4af8855ec02f6909316526bdd08\"","\"delete\":","\"dst_path\":","\"firmware\":","\"flash/changed_file.py\",","\"flash/lib/new_lib.py\",","\"flash/old_file.py\",","\"flash/other_old_file.py\"","\"hash\":","\"host\"","\"http://192.168.1.144:8000/1.0.1b/flash/changed_file.py\",","\"http://192.168.1.144:8000/1.0.1b/flash/lib/new_lib.py\",","\"http://192.168.1.144:8000/firmware_1.0.1b.bin\",","\"new\":","\"over","\"update\":","\"url\":","\"version\":","#","(also","(becaus","(http://epydoc.sourceforge.net/stdlib/distutils.version.loosevers","(if","(ota)","(over","(thi","(via","(wait","/manifest.json?current_ver=1.0.0","0x02,","0x03]):","0x05,","0x06]))","1.0.0","1.0.1","100%","192.168.1.144:8000\\r\\n\\r\\n","2","5)","8000","8000)","=","==","[","],","abil","abov","achiev","activation)","actual","addit","address","agnost","air","air\"","allow","along","although","any...)","app_eui","app_key","app_key),","appimg.bin","appli","area","around","ask","asset_that_will_be_removed.wav","at:","auth=(app_eui,","avail","back","backup","base","be","befor","below","between","block","bluetooth","boot.pi","both","bring","broadcast","browser","build","bytes([0x01,","call","capabilities.","certain","chang","changed.","chosen","class","class.","class.html).","client","code","code,","come","command","comment","compani","compat","complet","config","connect","connect.","contain","content.","copi","correspond","creat","current","current_v","custom","data","delet","delete:","demonstr","deploy","describ","devic","device.","devices.","differ","directori","directory:","do.","downlink","e.g.","e.g:","end","entir","etc.","even","exampl","example)","example,","example.","exist","expect","expire)","explain","fails,","featur","fetch","field","fields:","file","file,","files,","files.","firmare_version.bin,","firmwar","firmware,","firmware.","firmware:","firmware_1.0.0.bin","firmware_1.0.1.bin","flash","follow","forever...)","format","found","from.","ftp.","full","function","functional,","gener","geograph","green","hash","header","here","here.","high","higher","highest","home","http","http/1.0\\r\\nhost:","http://127.0.0.1:8000/manifest.json?current_ver=1.0.0","hundr","imag","image.","imagin","implement","implemented.","import","incas","initi","initialis","instead","instruct","interfac","join","joined...')","json","latest","layer","layers.","leav","led","left","level","lib","lib_a.pi","librari","like:","limit","list","longer","look","loosevers","lora","lora(mode=lora.lorawan,","lora,","lora.","lora.has_joined():","lora.join(activation=lora.otaa,","lorawan","main.pi","make","manifest","manifest.json.","mechan","mechanism.","messag","message,","meter","meter.","method","method.","methodolog","micropyton","mode.","modul","name","need","network","network.","new","new,","new:","new_lib.pi","non","note:","number","number,","number.","on","onc","order","ota","ota\")","ota.connect()","ota.update()","otaa","out","over","overview","pars","path","perform","point","port","possibl","potenti","power","previou","previous","previous_version:","print(\"perform","print('not","procedur","properli","provid","provis","pycom","pycom.heartbeat(false)","pycom.rgbled(0xff00)","python","python3.","rate","reason","receiv","regardless","region=lora.eu868)","regular","relat","request","requir","reus","roll","run","running,","s","s.recv(64)","s.send(bytes([0x04,","s.setblocking(false)","s.setblocking(true)","s.setsockopt(socket.sol_lora,","same","save","scheme","script","scripts.","sd","see","send","sent","serv","server","server_ip","server_ip,","set","setup","sever","sha1","shown","simpli","size","sleep","sleep(5)","smart","socket","socket.so_dr,","socket.sock_raw)","socket.socket(socket.af_lora,","some_asset.txt","sort","sourc","special","split","start","still","structure:","such","suggests).","system","test","there'","things:","this.","this_script.pi","though","thousand","time","time.sleep(2.5)","timeout=0)","top","transport","travel","trigger","true:","turn","tutori","two","two.","ubinascii","ubinascii.unhexlify('70b3d57ed0008cd6')","ubinascii.unhexlify('b57f36d88691cec5ee8659320169a61c')","unfeas","unfortun","until","up","updat","update,","update.","update:","upload","url","url'","url,","us","user","using.","usual","variable).","vehicl","vehicle.","veri","version","version.","version:","via","w","w.deinit()","wait","want","web","well","wifi","wifi_pw,","wifi_ssid,","wifiota","wifiota(wifi_ssid,","window","wish","without","wlan","wlan()","work","{","|","}","},"],"tutorials/all/rmt.html":["#","(1,0,1)","(1,0,1,1,0,1)","(1,0,1,1,1,0,1,0,1)","(100,","(400,200,100,300,200,400)","(8000,11000,8000,11000,6000,13000,6000,3000,8000)","(note:","(remot","(unlik","*","/","0","1","10","100","1000","1000*100n","1000*channel","10000","1000n","1000u","100hz,","100n","100u","102.4","10h","10m","2","2,","20","20*100n","2u","3","3.2768","3125n","32.768","4","4,","5","500u","6","7","70,","80","80%","=","`start_level`","abov","absolut","accordingly.","allow","along","alway","avail","base","be,","between","binari","bit","bit.","board","carrier","chang","channel","channels,","class","combin","configur","continu","control","control)","creat","data","data)","data,","defin","design","desir","detail","doesn't","don't","due","durat","duration[i]","duty,","each","esp32","exampl","example,","filter","first","first,","follow","forms.","found","frequency,","function","gener","given","gpio","gpio=\"p21\",","high","high,","hour","idle,","idle.","ignored.","import","in.","inform","infrar","inputs).","interpret","key","last","led","length","list","longer","longest","low","machin","machine.rmt(channel=2)","machine.rmt(channel=2,","map","maximum","mean","modul","modulation.","more","ms","nano","number","object","occur,","occurs.","opposit","out","output","p13","p18","p21","p21,","pattern","peripher","pin","place","primarili","produc","puls","pulse.","pulses,","pycom.pulses_get()","receiv","receiving,","remot","resolut","resolution,","resolution:","rmt","rmt(channel=4,","rmt.","rmt.high))","rmt.init()","rmt.init(gpio=\"p21\",","rmt.pulses_get()","rmt.pulses_get(pulses=100)","rmt.pulses_get(timeout=500)","rmt.pulses_send(duration,","rx_filter_threshold=20)","rx_idle_threshold","rx_idle_threshold=1000)","rx_idle_threshold=1000,","seconds,","send","set","shape","shorter","shown","signal","signal.","signals,","start","start_level=rmt.high)","state","state.","style","third","this.","timeout","toggl","transmiss","transmit","tupl","tuple,","two","tx_carrier","tx_idle_level","tx_idle_level=rmt.low)","tx_idle_level=rmt.low,","type","undefin","unit","until","us","us)","valid","valu","variou","wait","want","wave","well","width","without"],"tutorials/lora/":["\"special\"","(which","2","abp","access","ad","address","advanc","application.","basic","befor","benefit","both","build","call","case","channel","class","commun","connect","crc","custom","de","demonstr","device.","differ","direct","directli","encryption.","exampl","featur","follow","forwarder.","frame","frequenc","full","function","headers,","higher","implement","includ","inform","level","long","lopi","lopy.","lora","lora)","lorawan","mac","methods,","mode","mode.","modes;","modul","modulation.","new","otaa","packet","pass","plan","protocol","radio","rang","raw","receiv","remov","select","sent","stack","support","tail","those","tutori","typic","us","well","without","work","zealand."],"tutorials/lora/lora-mac.html":["#","&","'hello'","(raw","0x0f)","2","=","ad","address","amount","asia","australia","basic","be","below","below,","both","bypass","chanc","code","connect","creat","data","data.","delay","device:","directly.","encrypt","europ","exampl","example,","factor","format","frame.","frequency,","given,","import","inform","initialis","layer","loop","lopi","lopys.","lopy'","lora","lora(mode=lora.lora,","lora)","lora.as923","lora.au915","lora.eu868","lora.us915","lorawan","mac","machin","match","minimis","mode","modul","more","need","network","param","pick","pleas","power","print(data)","radio","random","raw","receiv","received...","region","region=lora.eu868)","run","s","s.recv(64)","s.send('hello')","s.setblocking(false)","s.setblocking(true)","same","see","send","sent","sides.","socket","socket.sock_raw)","socket.socket(socket.af_lora,","spread","state","time","time.","time.sleep(machine.rng()","transmit","true:","two","tx","unit","us","wait","way,","word"],"tutorials/lora/lorawan-otaa.html":["#","(becaus","(if","(over","(wait","0x02,","0x03]))","2","5)","=","accept","activation)","air","alway","any...)","app_eui","app_key","app_key),","appeui","appkey","arrive.","asia","attempt","australia","auth=(app_eui,","authent","authentication.","back,","befor","below","block","correct","creat","data","device:","europ","exampl","expire)","false.","forever...)","frame.","gateway","gateway.","get","has_joined()","import","incorrect","initialis","join","joined...')","keep","key","lopi","lora","lora(mode=lora.lorawan,","lora.as923","lora.au915","lora.eu868","lora.has_joined():","lora.join(activation=lora.otaa,","lora.us915","lorawan","make","match","messag","method","mind","mode.","modul","network","never","non","order","otaa","over","packet","paramet","pick","pleas","point","prevent","print('not","print(data)","provided.","rate","receiv","receive,","region","region=lora.eu868)","repli","request","respons","return","s","s.recv(64)","s.send(bytes([0x01,","s.setblocking(false)","s.setblocking(true)","s.setsockopt(socket.sol_lora,","send","sent","set","socket","socket.so_dr,","socket.sock_raw)","socket.socket(socket.af_lora,","stand","state","stuck","there'","therefor","time","time.sleep(2.5)","timeout=0)","to/from","ubinascii","ubinascii.unhexlify('11b0282a189b75b0b4d2d8c7fa38548b')","ubinascii.unhexlify('ada4dae3ac12676b')","unit","until","us","wait","window"],"tutorials/lora/lorawan-abp.html":["#","'handshake'","(activ","(becaus","(if","(such","(wait","0x02,","0x03]))","2","5)","=","abp","any...)","app_swkey","app_swkey))","arrive.","asia","attempt","australia","auth=(dev_addr,","authent","back,","befor","below","block","configur","creat","data","dev_addr","devic","device:","dure","encrypt","europ","exampl","exchang","expire)","forever...)","frame","frame.","gateway","get","import","initialis","join","keep","key","lora","lora(mode=lora.lorawan,","lora.as923","lora.au915","lora.eu868","lora.join(activation=lora.abp,","lora.us915","lorawan","make","manual","match","mean","mind","mode.","need","network","never","non","nwk_swkey","nwk_swkey,","on","order","otaa","packet","param","perform","personalisation.","personalization)","pick","pleas","prevent","print(data)","procedur","procedure).","rate","receiv","receive,","region","region=lora.eu868)","s","s.recv(64)","s.send(bytes([0x01,","s.setblocking(false)","s.setblocking(true)","s.setsockopt(socket.sol_lora,","send","sent","set","socket","socket.so_dr,","socket.sock_raw)","socket.socket(socket.af_lora,","stand","start","state","struct","struct.unpack(\">l\",","stuck","there'","therefor","ubinascii","ubinascii.unhexlify('00000005'))[0]","ubinascii.unhexlify('2b7e151628aed2a6abf7158809cf4f3c')","unit","us","wait","window","without"],"tutorials/lora/lora-mac-nano-gateway.html":["\"!bb%ds\"","\"bb%ds\"","\"bbb\"","\"devic","#","%","%d","%ds:","%s'","(200)","(ack","(device_id","(device_id,","(for","(len(recv_ack)","(len(recv_pkg)","(nodes)","(true):","0):","0x01","1","1,","115200)","2","2):","200)","200):","=","==",">","_lora_pkg_ack_format","_lora_pkg_format","ack","ack_pkg","act","adapt","allow","alway","appear","applic","arriv","asia","australia","avoid","b:","basic","between","bh%ds.","bitwis","boot.pi","byte","chang","code","code,","connect","contain","demo","demo,","develop","devic","device:","device_id","device_id):","device_id,","deviceid,","differ","discuss","else:","error","europ","exampl","failed\")","fals","format","format)","forum","gateway","gateway.","h","header,","here\"","identifi","import","increas","infinit","inform","introduc","invalid","keep","len(msg),","listen","loop","lopi","lora","lora(mode=lora.lora,","lora.as923","lora.au915","lora.eu868","lora.us915","lora_sock","lora_sock.recv(256)","lora_sock.recv(512)","lora_sock.send(ack_pkg)","lora_sock.send(pkg)","lora_sock.setblocking(false)","mac","machine.uart(0,","manipul","mark","match","max","max_time_wait","messag","method","more","msg","msg)","msg))","nano","needs:","network","network.","node","note:","ok","open","os","os.dupterm(uart)","packag","package,","package.","pick","pkg","pkg:","pkg_len,","pleas","port","post.","print","print(\"ack\")","print(\"messag","print('device:","put","raw","recv_ack","recv_ack)","recv_pkg","recv_pkg)","recv_pkg[1]","recv_pkg_len","recv_pkg_len,","reduc","region","region=lora.eu868)","resend","respons","response.","rx_iq","rx_iq=true,","see","send","serial","set","simpl","singl","size","size,","socket","socket,","socket.sock_raw)","socket.socket(socket.af_lora,","someth","specif","state","string","string)","struct","struct.pack(_lora_pkg_ack_format,","struct.pack(_lora_pkg_format","struct.unpack(_lora_pkg_ack_format,","struct.unpack(_lora_pkg_format","time","time.sleep(5)","true","two","tx_iq","tx_iq=true,","uart","unit","us","user","wait","waiting_ack","while(true):","while(waiting_ack):","within"],"tutorials/lora/module-module.html":["#","(nodes)","=","==","asia","australia","b","b'ping':","capabl","connect","device:","europ","exampl","import","lopi","lora","lora(mode=lora.lora,","lora.","lora.as923","lora.au915","lora.eu868","lora.us915","match","modul","network","node","pick","pleas","pycod","raw","region","region=lora.eu868)","s","s.recv(64)","s.send('ping')","s.send('pong')","s.setblocking(false)","show","socket","socket.sock_raw)","socket.socket(socket.af_lora,","state","time","time.sleep(5)","true:","two","unit","us","via"],"tutorials/lora/rn2483-to-lopy.html":["\"forever\".","#","#(should","12","125","250","4/5","48656c6c6f","8","868000000","868000000,","=","bandwidth=lora.bw_125khz,","between","bw","coding_rate=lora.coding_4_5,","cr","data","exampl","freq","frequency=","import","keep","listen","lopi","lora","lora(mode=lora.lora,","lora.","mac","microchip","mod","network","paus","power_mode=lora.always_on,","preamble=8,","prlen","public=false)","radio","raw","rn2483","rx_iq=false,","s","s.recv(64)","send","set","sf","sf7","sf=7,","show","socket","socket.sock_raw)","socket.socket(socket.af_lora,","sync","transmit","tx","tx:","tx_iq=false,","via","while(true):","‘hello')"],"tutorials/sigfox.html":["#","(e.g.","(europe)","(see","10,","11,","12]))","2,","3,","4,","5,","6,","7,","8,","9,","=","accepted.","affect","antenna","antenna),","backend","backend,","backend.","base","be","befor","between","block","board","both","button","byte","class","click","commun","configur","connect","connectivity,","corner.","countri","coverag","creat","damag","demonstr","devic","device,","device.","differ","disengag","downlink","drop","due","ensur","entri","exampl","expect","experienc","false)","finally,","fipi","firstli","follow","fsk","id","import","info).","inform","init","instance.","issu","larg","last","link","link.","log","lopi","lot","make","messag","mode","more","navig","need","network","network,","network.","next","now","number","number,","numbers.","occur","on","oper","out","outsid","page","pleas","prevent","proper","protocol","rcz","rcz1","rcz=sigfox.rcz1)","regist","replay","reset","right","s","s.send(bytes([1,","s.setblocking(true)","s.setsockopt(socket.sol_sigfox,","see","send","sending/receiv","sent","sequenc","sigfox","sigfox(mode=sigfox.sigfox,","sigfox.","sipy,","sipy.","socket","socket.so_rx,","socket.sock_raw)","socket.socket(socket.af_sigfox,","specifi","start","start,","support","sure","sync.","trash","tutori","type","type:","uplink","upon","upper","us","variou","via","well","without","zone","​"],"tutorials/lte/":["2g/3g/lte","are.","avail","both","carrier","cat","cell","cellular","check","connect","demonstr","enabl","exampl","follow","full","function","iot","iot,","local","long","lower","lte","m1","modul","modules.","nb","new","phones,","power,","protocols.","pycom","range,","requir","same","support","sure","them.","time","tutori","us","version","wide","writing,"],"tutorials/lte/cat-m1.html":["#","(data","/","1])","443)[0][","=","access","ad","adapt","address","after.","allow","appli","attach","aw","base","be","befor","best","board","case","cat","cellular","code","compatibility.","complet","connect","connection.","consumpt","consumption.","current","data","de","deepsleep","deepsleep.","disconnect","due","ensur","errat","event","exampl","examples.","expans","fipi","firmwar","first","found","full","function","give","go","google'","here.","higher","http/1.0\\r\\n\\r\\n\")","import","important:","includ","independ","initialis","initialised,","instance).","instanti","instruct","ip","jumper","keep","latest","lead","lte","lte()","lte.attach()","lte.connect()","lte.dettach()","lte.disconnect()","lte.isattached():","lte.isconnected():","m1","mean","minimum","modem","modem.","mqtt","network","object","obtain","onc","oper","order","out","over","pin","place","pleas","power","print(s.recv(4096))","radio","radio.","receiv","remov","requir","rout","rts/ct","s","s.close()","s.connect(socket.getaddrinfo('www.google.com',","s.send(b\"get","secur","sequan","server","servic","session","setup","simpli","sm","socket","socket.socket()","special","ssl","ssl.wrap_socket(s)","ssl:","start","station","step","system","taken","those","through","time","time.sleep(0.25)","together,","us","web","wlan"],"tutorials/lte/nb-iot.html":["#","(data","1\"')","=","allow","band","band=20\"')","be","befor","board","case","cat","class","consumpt","consumption.","current","de","deepsleep","deepsleep.","differ","due","ensur","errat","event","exampl","expans","fipi","firmwar","flash","found","go","here.","higher","import","important:","independ","initialis","initialised,","instance).","instruct","iot","jumper","keep","lead","lte","lte()","lte.connect()","lte.isattached():","lte.isconnected():","lte.send_at_cmd('at!=\"addscanband","lte.send_at_cmd('at!=\"clearscanconfig\"')","lte.send_at_cmd('at!=\"disablelog","lte.send_at_cmd('at+cfun=0')","lte.send_at_cmd('at+cfun=1')","lte.send_at_cmd('at+cgdcont=1,\"ip\",\"nb.inetd.gdsp\"')","m1,","minimum","modem.","modul","narrow","nb","need","network","now","onc","oper","order","out","pass","pin","place","power","pycom","radio","radio.","receiv","remov","requir","rts/ct","sequan","shipped,","sm","socket","special","support","system","taken","those","together,","us","usag","usual...","vodafone:"],"tutorials/lte/imei.html":["\"354347xxxxxxxxx\"\\r\\n\\r\\nok.","(sysname='gpy',","02","1.17.0.b1","2018","27',","849","=",">>>","\\r\\n+cgsn:","between","cellular","check","code","compat","d0dc708","devic","doubl","enabl","esp32')","firmwar","firmware,","firstli","follow","higher.","imei","imei.","import","interact","lte","lte()","lte.send_at_cmd('at+cgsn=1')","machine='gpi","make","modul","need","network","nodename='gpy',","number:","onc","order","os","os.uname()","pycom","quot","release='1.17.0.b1',","repl.","retriev","return","run","string","sure","valu","version","version='v1.8.6","via","you'll"],"tutorials/lte/firmware.html":["\"copyright\",","\"credits\"","\"help\",","\"license\"","\"recovery\"","\"stall\"","#","$","'/path/to/catm1","'/path/to/updater.elf')","'/sd')","'/sd/updater.elf')","(clang","(default,","(do","(e.g.","(i.e","(or","(we","/flash","08","09:51:46","1,","1.0.99","1.1,0,0","10%","100%","12341","13604","14:23:58)","20","2018","2018,","2048","25","3,","3.6.5","300k","306076","37781.dup","37781.dup',","37781.dup)","37781.zip","38638.dup","38638.dup')","38638.dup',","38638.zip","4.2.1","5","5.0.0.0d","5.1.1.0","54854","5996938","7","8192","9.1.0","902.0.39.1)]","99%.",":","=","==============",">>",">>>","[########################################]","[33080]","[38638]","[gcc","absolut","again","again.","alreadi","appl","apr","archive,","around","articl","ask","attempt","auto","automat","avail","be","befor","below.","board","bootloader0","bootloader1","bootloader1*","bootloader2","bootloader2*","bootrom","break","built","button","byte","bytes:","can't","card","card,","carefulli","case","cat","catm1","chang","check","close","code","come","command","command.","command:","commands.","commun","compar","compat","completed!","completed.","compon","comput","computer.","computer:","consol","contain","content","copi","copied/upload","current","darwin","days),","describ","desir","develop","devic","differ","directli","directori","disconnect","display","distributor","do","don't","done,","download","dup","dure","each","end","enough.","ensur","even","exampl","execut","exist","fact","fail","fail,","failur","fat","file","file,","file.","file:","files,","find","finish","fipy,","firmwar","first","first,","fit","flash","follow","format","ftp.","full","g01","go","gpy,","hang","hard","here'","here:","hold","however,","https://github.com/pycom/pycom","https://software.pycom.io/downloads/sequans2.html","images,","import","important:","importantly,","increas","indic","info","information.","insid","instal","instruct","integr","interfac","interrupt","iot","iot.","it'","it.","latest","libraries/tree/master/lib/sqnsupgrad","list","llvm","load","longer","look","lte","m1","machin","make","max","mbr","messag","method","method,","method:","minut","minutes,","mirror","mode","mode.","mode...","modem","modem,","modul","module'","module):","module,","module.","module:","more","mount","nb","nb1","necessari","necessary.","need","negotiation...","new","normal","note","now","nv","old","on","on_the_fli","onc","onto","opened:","options:","origin","os","os.listdir('/sd')","os.mkfs(sd)","os.mount(sd,","otherwis","otherwise,","output","over","packag","partition,","past","path","pc.","pleas","port.","power!!!)","power!!!)................","power!!!)............................................................................","power),","preced","prepar","press","previou","primari","process","prompt","publish","pybyt","pycom","pyseri","python","python3","read","reconnect","recoveri","relat","releas","repeat","requir","reset","respond","resum","retri","return","risk","robot","run","same","save","script","scripts:","sd","sd()","seem","select","send","serial","session","sever","signific","similar","singl","size","slightli","soft","softwar","specifi","specified,","specified.","speed","sqnsupgrad","sqnsupgrade.run('/sd/catm1","sqnsupgrade.run('/sd/nb1","sqnsupgrade.run('serial_port',","sqnsupgrade.uart()","sqnsupgrade.uart(true)","sqnsupgrade.uart(true,'/flash/updater.elf')","stabl","standard","start","step","steps:","store","stp","studio","success","successfulli","successfully,","summari","sure","switch","system","take","task","termin","terminal/atom","terminal:","this:","through","time,","tool","transfer","tutorial.","two","type","uart","ue","unless","unpack","up","updat","updater.elf","upgrad","upgrade.","upload","uploaded.","us","user","v1.18.1.r1","version","version.","version:","versions.","via","visual","wait","wakeup","wakeup...","window","without","zip","zsp0","zsp1"],"tutorials/pytrack.html":["#","#f.write(\"{}","'/sd')","'\\n')","'w')","(true):","=","accelerometer.","altern","both","coord","est","exampl","f","find","gc","gc.enable()","gc.mem_free()))","github","import","l76","l76.coordinates()","l76gnss","l76gnss(py,","librari","machin","machine.rtc()","math","micropygp","modul","network","ntp","open('/sd/gp","os","os.mount(sd,","pleas","print(\"{}","print('\\nrtc","print('adjust","py","pycom/pycom","pysens","pytrack","pytrack()","record.txt',","repository.","rtc","rtc.now())","rtc.now()))","rtc.now(),","rtc.ntp_sync(\"pool.ntp.org\")","same","sd","sd()","see","set","setup","time","time.sleep(2)","timeout=30)","timezone',","us","utc","utc:',","utim","utime.localtime(),","utime.sleep_ms(750)","utime.timezone(7200)","{}","{}\".format(coord,","{}\\n\".format(coord,"],"tutorials/pysense.html":["(csv)","3d.","=","acc","acc.pitch()","acc.roll()","acceleromet","avail","basic","board","comma","data","exampl","format","here","import","lis2hh12","lis2hh12()","orient","output","over","pitch","print('{},{}'.format(pitch,","process","py","pysens","pytrack","pytrack()","read","roll","roll))","script","separ","serial.","show","sketch","time.sleep_ms(100)","true:","valu","visualis","want"],"tutorials/pyscan.html":["#","(check_uid(list(uid),","(nfc,","(rgb_bright","0))","0):","0:","0x8","0x95,","0xdd,","0xf8],","0xf9]]","=",">","[0x43,","[[0x43,","_thread","_thread.start_new_thread(discovery_loop,","access","authent","basic","card","defin","detect","else:","exampl","execution...","find","github","import","librari","list.","main","mfrc630","mfrc630(py)","nfc","nfc.mfrc630_cmd_init()","nfc.mfrc630_cmd_reset()","pre","py","pycom","pycom.rgbled(rgb_blue)","pycom.rgbled(rgb_green)","pycom.rgbled(rgb_red)","pyscan","pyscan()","read","repositori","rgb_bright","rgb_red","show","start","this,","thread","time","time.sleep(.5)","uid_len))","us","valid_card"],"firmwareapi/introduction.html":["(function","(or","(via","applic","aspir","avail","availability/non","best","beyond","board.","board/embed","build","built","categori","chapter","class","claus","code).","configurable,","contain","content","describ","descript","document","documentation,","each","effort","entir","even","extend","extens","featur","feature.","filter","find","found","function","functionality,","functions/class","further","gener","given","highli","however,","implement","individu","inform","information”","intend","introduct","it,","items,","lib","librari","libraries)","libraries.","library,","make","mani","mark","micropython","micropython.","mind,","modul","module)","modules:","more","non","note","number","offici","out","particular","pertain","place","pleas","port","port.","portable.","ports,","provid","provis","python","repository.","section","specif","standard","still","subset","support","system","thu","unavail","user","user.","warn","well","“availability:”","“gener"],"firmwareapi/pycom/":["(i.e.","access","bluetooth,","devic","devices).","differ","e.g.","etc.","hardware,","i2c,","implement","includ","micropython","modul","non","pycom","slightli","specif","spi,","support","those","underli","variat","wlan,"],"firmwareapi/pycom/machine/":["#","(1","(30000","(data","(except","(fipy,","(in","(on","(so","(the","(wake_reason,","10","20000.","24","30","4","6","=","achiev","address)","address.","allow","allows.","anoth","another,","are:","argument","associ","be","befor","bit","board","board.","board/soc","board/soc.","boot.pi","boot.py.","button","button.","byte","call","capabl","capacit","case","caus","cause.","class","clock","close","combin","come","common","configur","connect","constant","consumpt","contain","continu","convert","correspond","cpu","cpu,","critic","deep","deepsleep","deepsleep.","default","devic","disabl","disable_irq","display","down","due","durat","dure","eas","element","elsewhere.","enabl","enable_irq","enable_pul","enable_pull)","enter","esp32","esp32).","event","exampl","example,","execut","executed.","exit","expect","extern","file","filenam","finished.","form","form:","frequenc","full","function","g01),","gate","gener","given","gpio","gpio_list).","gpy,","hardwar","help(machine)","hertz.","hexadecim","high","id","id).","identifi","import","includ","independ","instanc","instance).","integ","interfac","interrupt","interv","irq","keep","length","list","long","lopy'","lte","lte).","mac","machin","machine.brown_out_reset","machine.deepsleep([time_ms])","machine.deepsleep_reset,","machine.disable_irq()","machine.enable_irq([state])","machine.freq()","machine.hard_reset,","machine.idle()","machine.info()","machine.main(filename)","machine.pin_deepsleep_wakeup(pins,","machine.pin_wake,","machine.pwron_reset,","machine.pwron_wake,","machine.remaining_sleep_time()","machine.reset()","machine.reset_cause()","machine.rng()","machine.rtc_wake,","machine.soft_reset,","machine.ulp_wak","machine.unique_id()","machine.wake_reason()","machine.wakeup_all_low","machine.wakeup_all_low,","machine.wakeup_any_high","machine.wakeup_any_high.","machine.wdt_reset,","main","main.pi","make","mani","manipul","manner","mark","member","micropython","millisecond","millisecond).","milliseconds)","miscellan","mode","mode,","mode.","modul","module.","ms)","network","number.","occur","option","order","origin","otherwis","out","overflow","p10","p13","p2,","p23.","p3,","p4,","p6,","p8","pad,","parameters.","pass","period","periods.","peripher","peripherals,","pin","port","ports,","possibl","power","pressed.","previou","product","pull","push","quick","radio","random","reason","reason.","receiv","reduc","regular","relat","remain","repres","requests.","requir","reset","reset.","resistor","restor","resum","return","run","script","script,","second","section.","see","select","sens","separ","set","setup","short","similar","sleep","sleep.","sm","softwar","someth","soon","specif","stack","stack.","state.","stop","string","substr","system","taken","task","tasks,","time","time,","timer","timer.","touch","trigger","true","true,","tupl","ubinascii.hexlify()","ulp","underli","uniqu","until","up","us","usag","valu","values.","vari","variabl","variou","via","wake","wakeup","wakeup.","water","way","wifi","within","woken","word","work","zero"],"firmwareapi/pycom/machine/adc.html":["#","(in","(re)init","*",",","0","1.1v","1.1v.","11db.","12","3.3v","3.3v,","9","=","adc","adc.attn_0db,","adc.attn_11db","adc.attn_2_5db,","adc.attn_6db,","adc.channel","adc.channel(*","adc.channel(pin='p16')","adc.deinit()","adc.init(","adc.vref(vref)","adc.vref_to_pin(pin)","adcchannel","adcchannel()","adcchannel.","adcchannel.deinit()","adcchannel.init()","adcchannel.value()","adcchannel.value_to_voltage(value)","adcchannel.voltage()","analog","apin","apin()","are:","argument.","arguments,","associ","attenu","attn","attn=adc.attn_0db)","automat","avoid","between","bit","bits=12)","block.","calibr","call","channel","channel.","check","class","connect","constant","constructor","convers","convert","creat","creation.","current","damag","device.","digit","disabl","does.","enabl","exampl","example:","exce","extern","fast","function","gpio","gpio.","hardwar","highest","import","increas","info","input","instanc","intern","internal/extern","keyword","level.","machin","machine.adc()","machine.adc(id=0)","maximum","mcu","method","method.","millivolts)","modul","more","number","object","object;","otherwis","p13","p16","p20.","p21","p22,","p6","p6.","pin","pin,","pin.","pins.","point","provid","quick","radio.","rang","read","recommend","reference.","resolut","return","same","section.","select","sources.","string","support","take","up","updat","us","usag","val","valid","valu","value.","values:","voltag","way","wipy,","without","–"],"firmwareapi/pycom/machine/dac.html":["#","(a","(~","(~0.4","(~0.8","(~1.5","0","0)","0dbv","1","1.","122hz.","125hz","12dbv","18dbv","1khz","2","20khz","3","3.3v.","3vpp","50%","600","6dbv","=","amplitud","amplitude)","analog","argument,","argument.","associ","automat","between","block.","call","channel","class","constructor","creat","creation.","dac","dac.deinit()","dac.init()","dac.tone(frequency,","dac.write(0.5)","dac.write(value)","dac_ton","dac_tone.tone(1000,","dc","disabl","enabl","exampl","float","frequenc","gener","import","integ","level","load)","machin","machine.dac('p21')","machine.dac('p22')","machine.dac(pin)","method","object","object,","offset","ohm","output","p21.","p22","pin","pin.","quick","represents:","scale.","set","signal","sine","specif","specifi","step","string","tone","up","us","usag","valu","vdd/2.","voltag","voltage)","vpp)","vpp),","vpp).","wave","write"],"firmwareapi/pycom/machine/i2c.html":["#","'123')","'abc'","'abc')","'hello')","'xy')","(0).","(3","(includ","(or","(p10=sda,","(scl)","(sda)","(typic","*","*,",",","...)","0","0,","0x08","0x10","0x10,","0x42","0x42,","0x77","1","1,","16.","2","2)","2,","2.","3","3)","5","5)","8","=","act","addr","addr.","address","address.","address:","addrsiz","addrsize=8)","argument","assign","associ","attach","b'456')","bang","baudrat","baudrate=100000)","baudrate=100000,","baudrate=20000)","between","bit","bit)","bu","buf","buf)","buf,","buf.","bus,","bus.","buse","byte","byte.","bytes)","case","class","clock","commun","condit","configur","configuration.","consist","constant","construct","constructor","continu","conveni","creat","created,","data","default","devic","device.","devices.","driver.","esp32","exampl","fals","follow","function","gener","give","given","given,","hardwar","i2c","i2c(0)","i2c(0,","i2c.deinit()","i2c.init(i2c.master)","i2c.init(i2c.master,","i2c.init(mode,","i2c.mast","i2c.master)","i2c.master,","i2c.master:","i2c.readfrom(0x42,","i2c.readfrom(addr,","i2c.readfrom_into(addr,","i2c.readfrom_mem(0x42,","i2c.readfrom_mem(addr,","i2c.readfrom_mem_into(addr,","i2c.scan()","i2c.writeto(0x42,","i2c.writeto(addr,","i2c.writeto(addr=0x42,","i2c.writeto_mem(0x42,","i2c.writeto_mem(addr,","implement","import","inclus","inform","init","initialis","integ","keyword","later","length","level","line","list","low","machin","machine.i2c(bus,","master","memaddr,","memaddr.","memori","method","methods:","mode","mode.","nbyte","nbytes)","nbytes,","non","number","object","on","on.","oper","option","p10","p11=scl)","p9","parameters:","peripher","physic","pin","pins=('p10','p11'))","pins=(sda,","print","protocol","pull","quick","rate","read","read.","receiv","recipient'","registers)","respectively.","respond","respond.","return","scan","scl","scl))","sda","sda,","second","select","send","sent","set","singl","slave","slave,","softwar","specif","specifi","standard","start","stop","stop=true)","such","take","target","those","timeout","to.","transaction).","transaction:","treat","tupl","turn","two","us","usag","valid","valu","wire","wires:","won't","write","written","written."],"firmwareapi/pycom/machine/pin.html":["#","%","%s\"","(also","(arg.id()))","(fast)","(input,","(or","*",",","...)","0","1","1)","=","`p10`","`p9`","adc","addit","alt","alt)","alt=","altern","analog","anyth","appli","are:","arg","arg=none)","argument","argument,","argument.","associ","attribut","avail","basic","board.","boolean.","call","callable.","callback","callback.","chang","changes.","class","class.","clear","configur","constant","constructor","contain","control","convert","core","creat","deep","def","depend","details.","digit","disabl","domain","down","drain","ed","edge.","empti","enabl","enabled.","etc)","event","events.","exampl","example:","examples:","expans","fall","false).","fast","follow","function","function.","gener","given,","gpio","handl","handler","handler=none,","happens.","held,","here.","high","high,","hold","hold.","i/o","id","id.","import","inform","initi","initialis","input","input/output).","instanc","interrupt","interrupts,","it.","known","led","left","level","level.","logic","low","low.","machin","machine.pin(id,","make","method","mode","mode.","mode:","mode=pin.in,","mode=pin.out)","mode=pin.out,","module.","more","new","none","none,","none.","note","object","objects.","of:","on","open","option","otherwis","out","output","output,","p","p10,","p13,","p14,","p15,","p16,","p17,","p18,","p19,","p2,","p20,","p21,","p22,","p23","p3,","p4,","p6,","p8,","p9,","p_in","p_in()","p_in.callback(pin.irq_fal","p_out","p_out(true)","p_out.toggle()","p_out.value(0)","p_out.value(1)","pass","pin","pin('p10',","pin('p12',","pin('p9',","pin()","pin([value])","pin(pin.exp_board.g16,","pin(pin.module.p9,","pin,","pin.","pin.callback(trigger,","pin.exp_board","pin.exp_board.g16","pin.exp_board.g16.id()","pin.hold([hold])","pin.id()","pin.in","pin.in,","pin.init()","pin.init(mode,","pin.irq_fal","pin.irq_high_level","pin.irq_low_level","pin.irq_ris","pin.irq_rising,","pin.mode([mode])","pin.modul","pin.module.p9","pin.module.p9.id()","pin.open_drain","pin.out","pin.out,","pin.pull([pull])","pin.pull_down","pin.pull_up","pin.pull_up,","pin.toggle()","pin.value()","pin.value([value])","pin:","pin_handler(arg):","pin_handler)","ports.","possibl","power","print(\"got","product","provid","pull","pull,","pull.","pull=none,","pull=pin.pull_up)","purpos","push","pycom'","quick","receiv","released.","reset","reset.","resistor","resistor.","resistor:","retain","return","returns:","rise","rtc","see","select","set","shortcut","sleep","state","string","support","system","through","time","together,","toggl","trigger","trigger=pin.irq_fal","true","true,","type","until","up","us","usag","valu","value,","value:","watchdog","|"],"firmwareapi/pycom/machine/pwm.html":["#","(thi","*",",","0","0,","1","1.","3.","30%","50%","5khz","7.","78","=","argument,","argument.","between","chang","channel","channel.","class","connect","constructor","creat","cycl","cycle.","duti","duty_cycl","duty_cycle=0.5)","exampl","float","frequenc","frequency)","frequency.","frequency=5000)","futur","hz","id","import","initi","instanc","integ","keyword","khz","machin","machine.pwm(timer,","method","modul","object.","oscil","p12","pin","pin,","pin='p12',","puls","pwm","pwm(0,","pwm.channel(0,","pwm.channel(id,","pwm_c","pwm_c.duty_cycle(0.3)","pwmchannel","pwmchannel.","pwmchannel.duty_cycle(value)","quick","return","set","specifi","string","timer","up","upgrades).","us","usag","valu","width","–","—"],"firmwareapi/pycom/machine/rtc.html":["#","(sntp).","(tz","(year,","*",",","...)","0)","0))","0,","0.","1,","10,","10:30am","13,","15","2,","2017","28,","2nd","30,","4,","5,","=","accord","achiev","are:","argument","automat","between","class","clock","completed,","connected.","constant","constructor","creat","current","date","datetim","day[,","default","disabl","drive","exampl","example.","example:","fals","februari","fetch","form:","geograph","hour[,","id","ignor","import","init","initialis","initialisation.","keep","last","like:","locat","machin","machine.rtc(id=0,","method","method.","microsecond[,","minute[,","month,","more","multipl","none","ntp","ntp_sync","number","object.","option","oscil","otherwise:","paramet","pass","period","print(rtc.now())","quick","results.","return","rtc","rtc()","rtc(id=0)","rtc.","rtc.init((2014,","rtc.init((2017,","rtc.init(datetime=none,","rtc.internal_rc","rtc.internal_rc,","rtc.now()","rtc.ntp_sync(\"pool.ntp.org\")","rtc.ntp_sync(server,","rtc.synced()","rtc.xtal_32khz","second","second[,","seconds.","see","select","server","server.","set","shortest","similar","sourc","source:","source=rtc.internal_rc)","specif","time","time.","time.timezon","track","true","tupl","tuple:","tzinfo","tzinfo]]]]])","up","updat","update_period","update_period=3600)","updates.","url","us","usag"],"firmwareapi/pycom/machine/spi.html":["#","(``p10``,","(``p19``,","(it","(p10","*",",","...)","0","0.","0x02,","0x03,","0x04,","0x05]))","0x05]),","1","1,","16","2mhz","3","32.","5","8,","=","@","``p11``","``p14``)","``p20``","``p21``)","accept","addit","any).","argument","assign","at.","baudrat","baudrate=1000000,","baudrate=2000000,","bit","bit:","bits=8,","both","bu","buf","buf.","buffer","bus,","bus.","bus:","byte","bytearray(5)","class","clk,","clk,p11","clock","configur","constant","construct","constructor","contain","creat","data","default","differ","driven","each","edg","exampl","extra","first","firstbit","firstbit=spi.msb)","firstbit=spi.msb,","given","given,","i2c;","id","idl","import","init","initialis","initialisation.","initialised.","last","length.","level","line","lines:","machin","machine.spi(id,","made.","main","master","master.","master:","method","miso","miso))","miso).","miso.","mode","mode,","mode=spi.master,","model","mosi","mosi,","nbyte","non","none","number","object","option","p14","paramet","parameters,","parameters:","pass","phase","phase=0)","phase=0,","physic","pin","pins=('p19','p20','p21'))","pins=(clk,","polar","polarity=0,","protocol","quick","rate.","rbuf","rbuf)","read","read.","read_buf)","read_buf.","receiv","requir","respectively.","return","same","sampl","sck","sck,","second","see","select","send","serial","set","signific","similar.","sit","specifi","spi","spi(0,","spi.deinit()","spi.init(mode,","spi.lsb","spi.lsb.","spi.mast","spi.master.","spi.msb","spi.read(5)","spi.read(nbytes,","spi.readinto(buf,","spi.write(buf)","spi.write(bytes([0x01,","spi.write_readinto(bytes([0x01,","spi.write_readinto(write_buf,","transfer,","tupl","turn","us","usag","valu","veri","width","write","write.","write=0x00)","write_buf","written","written."],"firmwareapi/pycom/machine/uart.html":["#","'p21',","'p22',","'p23'))","(0)","(``p20``","(``p20``,","(``p3``","(along","(in","(not","(p0)","(p1)","(txd/rxd","*",",","...)","0,","1","1,","1.5","10","13","2","2.","3","4","5","5,","6,","7","7,","8","8.","9600)","=","``p21``)","``p21``,","``p22``and","``p23``)","``p4``)","act","anyth","appli","assign","avail","available.","base","baudrat","baudrate.","baudrate=9600)","baudrate=9600,","bit","bits,","bits.","bits=8,","break","bu","buf","buf.","buffer","bus.","byte","bytes.","cellular","charact","character)","character.","characters,","characters.","check","class","clock","commun","complete.","condit","configur","confus","consist","constant","construct","constructor","contain","control","control)","creat","ct","cts))","cts.","data","default","defin","disabled.","done","drive","duplex","durat","elapses,","end","exampl","exists,","exists.","false.","flow","functionality.","given","given,","gpy/fipi","hardwar","here","immediate.","implement","import","in.","indic","init","initialis","irq","it,","item","last","len(buf)","level","limit","line","line,","lines:","list","low","machin","machine.uart(bus,","made","made.","mani","method","methods:","much","multipli","nbyte","nbytes])","newlin","non","none","none):","none,","none.","number","object","on","only)","oper","order).","otherwis","otherwise,","paramet","parameters:","pariti","parity,","parity=none,","per","physic","pin","pins.","pins=('p20',","pins=('p20','p21'))","pins=(txd,","pins=none,","possible.","protocol.","quick","radio.","rate.","read","read,","reading.","regardless","return","rt","rts,","rx","rxd","rxd,","same","select","send","sent","serial","set","sources:","specifi","standard","stop","stop=1)","stop=1,","store","stream","string","such","take","taken,","therefor","time","timeout","timeout.","timeout_char","timeout_chars=2,","timeout_m","transact","transmit","trigger","true","turn","tx","txd","txd,","txd.","type","uart","uart(1,","uart.any()","uart.deinit()","uart.even","uart.even,","uart.init(9600,","uart.init(baudrate=9600,","uart.odd","uart.odd.","uart.read(10)","uart.read(5)","uart.read([nbytes])","uart.readall()","uart.readinto(buf)","uart.readinto(buf[,","uart.readline()","uart.rx_ani","uart.sendbreak()","uart.wait_tx_done(timeout_ms)","uart.write('abc')","uart.write('hello')","uart.write(buf)","uart/usart","uart2","uart_1","unavail","unit","up","us","usag","use:","using:","valu","value:","wait","well.","whether","wide.","write","written"],"firmwareapi/pycom/machine/wdt.html":["\"feed\"","#","0.","2","=","applic","call","class","configur","constructor","correctly.","crash","creat","enabl","enabling,","end","ensur","everyth","exampl","expir","fed","feed","function","given","id","import","init","initialis","initialisation.","it.","machin","machine.wdt(id=0,","method","milliseconds.","non","object","onc","paramet","period","place","point","prevent","quick","re","recover","reset","restart","run","second","see","sensibl","start","state.","stop","system","system.","time.","timeout","timeout)","timer.","up","us","usag","verifi","watchdog","wdt","wdt(timeout=2000)","wdt.feed()","wdt.init(timeout)"],"firmwareapi/pycom/machine/timer.html":["#","%","%f","(float),","(for","(integer)","(integer).","(total","*","+=",",","0","0.","1","1,","1.25","10","10,000u","100u","100us.","10:","=","==","__init__(self):","_seconds_handler(self,","alarm","alarm):","alarm.","alarm.callback(handler,","alarm.cancel()","alarm:","arg","arg:","arg=none)","arg=none,","argument","be","bigger","call","callback","chrono","chrono.read()","chrono.read_ms()","chrono.read_us()","chrono.reset()","chrono.start()","chrono.stop()","chrono:","chronomet","chronometer.","class","class.","clock","clock()","clock:","close","compens","concept","condit","constructor","count","creat","creation.","def","delay","differ","disabl","disabled.","elaps","elapsed.","element","enforced).","exactitud","example,","example:","finish","first","function","function.","gil","given","great","group","guarante","handl","handler","handler:","import","inform","intern","interrupt","interrupts,","interv","interval.","lap","lap\"","lap)","lap))","last","longer","machin","mani","measur","method","microsecond","microseconds,","microseconds.","milisecond","milliseconds.","more","ms,","needed.","none","none,","notes.","notifi","number","object","object.","on","option","overhead,","paramet","pass","passed\"","periodic:","periodic=false)","periodic=true)","posit","print(\"","print(\"%02d","print(\"\\nth","print()","product","pycom'","race\"","racer","read","realli","receiv","releas","repeatedli","reset","run,","s,","same","second","seconds.","see","self.__alarm","self.second","self.seconds)","set","simul","span","spans.","specif","specifi","specified,","specified.","speed,","start","stop","subclasses:","tasks,","that.","thread","time","time.sleep(1.25)","time.sleep(1.5)","timer","timer.alarm(handler=none,","timer.alarm(self._seconds_handler,","timer.chrono()","timer.sleep_us()","took","total","total)","trigger","true.","two","us","us,","us:","varieti","without","–"],"firmwareapi/pycom/machine/sd.html":["#","'/sd')","'r')","'w')","(no","...)","/sd","1","32","=","addit","allow","automat","bit","boards,","card","card,","card.","check","class","cmd","combin","compat","configur","connect","constructor","content","creat","current","dat0,","disabl","enabl","exampl","expans","extern","f","f.close()","f.readall()","f.write('test","fat16","fat16/32","fat32.","file","firmwar","follows:","format","futur","gb.","implement","import","increas","initialisation.","insert","librari","machin","machine.sd(id,","make","memori","method","micro","mode.","modul","mount","needed)","note","object.","on","open('/sd/test.txt',","oper","operations')","os","os.listdir('/sd')","os.mount(sd,","p23:","p4:","p8:","paramet","part","pin","pleas","pull","pycom","quick","resistor","run","sclk","script.","sd","sd()","sd.deinit()","sd.init()","sd.init(id=0)","see","simpli","singl","sizes.","socket","standard","support","sure","system.","tri","up","updat","us","usage:","work","write"],"firmwareapi/pycom/machine/can.html":["#","'p23'))","(0x020,","(0x040,","(0x200,","(>=","(can","(extended).","(filter,","(id,","(id=0x012,","(if","(in","(rtr=true).","(standard)","*","*,",",","...)","0","0.","0.2).","0x001","0x010),","0x010,","0x02,","0x020","0x03,","0x030","0x030),","0x04,","0x040","0x05,","0x050)])","0x050.","0x05]),","0x06,","0x07,","0x08]))","0x100,","0x200,","0x300","0x300,","0x400","0x400])","0x7fc)])","0x7ff),","1","1000000.","11bit","128),","2,","2.0","29bit","3","3,","32","4,","5","5,","6,","7,","8","8]))","=",">>>","[(0x001,","[(0x100,","[0x100,","accept","accepted.","ad","allow","alway","any)","applied.","are:","arg","arg=none)","argument","argument.","automatically,","available,","available.","base","baudrat","baudrate=500000,","be","between","bit","bu","built","bus,","bus.","byte","bytes.","call","callback","callback.","can(0,","can(mode=can.normal,","can.callback(handler=can_cb,","can.callback(trigger,","can.deinit()","can.events()","can.filter_list","can.filter_list,","can.filter_mask","can.filter_rang","can.filter_range,","can.format_both,","can.format_both.","can.format_ext,","can.format_std","can.format_std,","can.init(mode=can.normal,","can.norm","can.normal,","can.recv()","can.recv(timeout=0)","can.rx_fifo_not_empti","can.rx_fifo_not_empty,","can.rx_fifo_overrun","can.rx_fifo_overrun,","can.rx_fram","can.rx_frame,","can.send(id,","can.send(id=0x0020,","can.send(id=0x010,","can.send(id=0x012,","can.send(id=12,","can.silent,","can.silent.","can.soft_filter(can.filter_list,","can.soft_filter(can.filter_mask,","can.soft_filter(can.filter_range,","can.soft_filter(mode,","can.soft_filter(none)","can_cb(can_o):","can_o.recv())","class","classic","clear","constant","constructor","contain","control","controller,","controller.","creat","data","data,","data=b'123',","data=bytes([0x01,","data=bytes([1,","data=none,","def","defin","devic","disabl","drop","due","e.g.","ed","elements.","empti","esp32","event","exampl","example:","extend","extended)","extended=false)","extended=true)","externally.","extnt","fals","fifo","fifo.","fill","filter","filter_list","filter_list)","filtering.","filters,","float","follow","form:","format","frame","frame_format","frame_format=can.format_std,","frames,","full","full.","function","handler","handler=none,","happens.","high","id","id=0x12","identifi","immedi","import","indic","init","initi","initialisation.:","instanc","intern","interrupt","it.","larg","left","length.","like:","list","machin","machine.can(bus=0,","mask","mask).","match","mean","messag","message.","messages,","method","method.","mode","mode=can.normal,","modes:","more","name","need","new","non","none","none,","normal.","note","number","object","object.","occur","on","option","order","order).","otherwis","overhead","paramet","pass","peripher","pin","pins=('p22',","pleas","point","possibl","present,","present:","print('can","queu","queue","queue,","queue.","quick","rang","receiv","received.","receiver.","recommend","registri","relev","remain","remot","request","request.","return","rtr","rtr,","rtr=false,","rtr=true)","rx","rx:',","rx_queue_len","rx_queue_len=128,","s","second","see","select","selected,","send","sent","set","silent","sn65hvd230.","snif","soft","softwar","special","specif","specifi","speed.","standard","support","take","tale","test.","therefor","this:","time","timeout","together,","traffic","transceiv","trigger","trigger=can.rx_fram","trigger=can.rx_frame)","tupl","tx","tx,","type","up","us","usag","valu","versa.","vice","well","whenev","width","won't","|"],"firmwareapi/pycom/machine/rmt.html":["\"idle\"","#","(1,0,1,0,1,0,1,0,1)","(high/low)","(level,","(remot","(resolution)","0","0%","1","1.","100%.","10000","1000n","100n","102.4","128","2","3","3.2768","31.","3125n","32.768","4","5","6","65535.","7","7.","=","abov","accept","addit","again","anoth","anyth","argument","be","below","between","bit","bit/pulse,","bits,","board","both","call","carrier","carrier'","carrier_duty_perc","carrier_freq_hz","carrier_level","case","channel","channel,","channel.","channel:","class","compos","configur","configuration.","constant","construct","constructor","contain","control","control)","creat","data","data)","data,","data.","defin","defined,","deinit()","deinitialis","depend","design","desir","dictat","drop","due","durat","duration):","duration,","duration.","duti","each","elements,","elements.","equal","evalu","exactli","example:","exceeded.","extra","finished,","first","follow","frequenc","frequency,","function","gener","given","given,","given.","gpio","gpio=\"p20\",","hz.","ignor","import","incom","indefinitely.","infrar","init","init()","initialis","initialisation.","initialised.","item","keep","kept","key","last","led","length","less","level","limit","longer","machin","machine.rmt(channel,...)","machine.rmt(channel=3)","machine.rmt(channel=3,","mandatori","match","maximum","mention","method","microseconds.","mind","minimum","mode","modul","modulate,","more","ms","need","number","number,","object","object.","occur","on","only.","optional.","output","paramet","parameter.","parameters,","parameters.","parameters:","percent","peripher","pin","pin.","primarili","provid","provided,","puls","pulse,","pulse.","pulse:","pulses,","pulses.","pulses_get","pycom.pulses_get()","quick","read","receiv","reception.","reconfigur","remot","repres","resolut","rest","return","rmt","rmt.deinit()","rmt.high","rmt.init(gpio,","rmt.init(gpio=\"p20\",","rmt.low,","rmt.low.","rmt.pulses_get(pulses,","rmt.pulses_send(duration,","rmt.recv_pulses()","rmt.send_pulses(duration,","row","rtm","rx","rx/tx","rx_filter_threshold","rx_filter_threshold,","rx_idle_threshold","rx_idle_threshold,","rx_idle_threshold.","rx_idle_threshold=12000)","same","see","select","send","send.","sent","sent,","sent/receiv","sequenc","seri","set","shorter","signal","signal'","signal,","signal.","signals.","singl","specifi","specified,","start_level","start_level)","state","structure:","time","timeout","timeout)","toggl","transmiss","tupl","tuples,","tx","tx/rx,","tx_carrier","tx_carrier)","tx_idle_level","tx_idle_level,","tx_idle_level=0)","type","unit","until","us","usag","use.","valid","valu","value.","value:","variou","wait","width","within","without"],"firmwareapi/pycom/network/":["access","avail","configur","configuration.","driver","hardwar","interfaces.","modul","network","provid","rout","specif","us","within"],"firmwareapi/pycom/network/wlan.html":["\"tradit","#","'192.168.0.1'))","'192.168.0.1',","'255.255.255.0',","'8.8.8.8'))","'my_network_key'))","'your","(but","(e.g.","(extern","(ip,","(onli","(p12)","(sec,","(sec,).","(ssid,","(the","*",",","...)","0,","1","11.","1:","2048","3","4","6","=","abc1de45bf).","access","address","address.","alreadi","alway","antenna","antenna,","antenna.","antenna=none,","antenna=wlan.int_ant)","ap","ap)","ap.","applic","are:","argument","auth","auth=(network.wlan.wpa2,","auth=(wlan.wpa2,","auth=(wlan.wpa2,'www.wipy.io'),","auth=none,","authent","avail","besid","between","bit","board","bssid","bssid,","bssid=none,","byte","ca","ca_cert","ca_certs=none,","case","certfil","certfile=none,","certif","certificate.","certifl","channel","channel,","channel=1,","channel=7,","class","client","code","config","config=['dhcp'","configtuple])","configur","configuration.","configured.","connect","connected,","constant","constructor","creat","default","develop","dhcp","disabl","disconnect","dns)","dns_server).","do:","done","driver","element","elements:","enabl","esp32","exampl","example,","exist","extern","fals","featur","fix","format","format).","free","function","gateway,","get/set","given","given,","given.","go","handl","hexadecim","hidden","hidden=false)","id","ident","identity=none)","import","info","init","initialis","instanc","instance:","interface.","intern","internal).","ip","it.","it'","key","key'))","key).","key.","keyfil","keyfile=none,","list","long","mac","machin","mandatory.","maximum","maximum.","method","millisecond","mode","mode).","mode,","mode.","mode:","mode=pin.out)(true)","module,","module.","name","name.","need","negoti","network","network.wlan(id=0,","network.wlan(mode=network.wlan.sta)","none","none,","note","now","number","object","object,","oem","option","otherwise.","output","p12","param","paramet","parameters.","part","pass","password","password),","password.","path","perform","pin","pin('p12',","pin.","pkcs8","point","point.","power","power_sav","power_save=false,","print(wlan.ifconfig())","privat","processor","provid","quick","radio.","rang","re","repres","return","rsa","rsaprivatekey\"","rssi).","same","save","scan","sec","sec,","secur","security.","security:","see","select","sens","server.","set","setup","sever","socket","special","ssid","ssid',","ssid,","ssid.","ssid='wipi","ssid=none,","ssleay","sta","static","station","string","subnet,","subnet_mask,","subsystem","succeed.","system","thekeyfil","things.","time","time.sleep_ms(50)","timeout","timeout=none,","to.","true","true.","tupl","tuple,","tuple.","type","type:","us","usag","usage:","used,","usernam","username,","usual","valid","valu","values.","wait","wifi","wipy.","without","wlan","wlan',","wlan(mode=wlan.sta)","wlan.antenna([antenna])","wlan.ap","wlan.ap,","wlan.ap.","wlan.auth([auth])","wlan.channel([channel])","wlan.connect('your","wlan.connect(ssid,","wlan.connect(ssid='mynetwork',","wlan.deinit()","wlan.disconnect()","wlan.ext_","wlan.ext_ant.","wlan.ifconfig(config=('192.168.0.107',","wlan.ifconfig(config=('192.168.0.4',","wlan.ifconfig(id=0,","wlan.init(mode,","wlan.init(mode=wlan.ap,","wlan.init(mode=wlan.sta)","wlan.int_ant,","wlan.isconnected()","wlan.isconnected():","wlan.mac()","wlan.mode([mode])","wlan.scan()","wlan.ssid([ssid])","wlan.sta,","wlan.sta_ap","wlan.sta_ap.","wlan.wep","wlan.wep,","wlan.wpa,","wlan.wpa2","wlan.wpa2,","wlan.wpa2.","wlan.wpa2_","wlan.wpa2_ent."],"firmwareapi/pycom/network/server.html":["#","'password'),","'python'),","(and","(connect","(in",",","...)","=","accept","affect","again","behaviour","both.","chang","check","class","class'","configur","connections),","constructor","control","creat","device.","disabl","effect","enabl","exampl","example:","fals","ftp","import","init","initialisation.","instance,","login=('micro',","method","network","network.server()","network.server(id,","new","option","otherwise.","paramet","passed.","password","perform","pycom","quick","return","run","second","seconds)","see","server","server(login=('user',","server).","server.","server.deinit()","server.init(*","server.init(login=('user',","server.isrunning()","server.timeout()","server.timeout(300)","server.timeout([timeout_in_seconds])","servic","set","start","stop","telnet","timeout","timeout.","timeout=300)","timeout=60)","timeout=600)","true","us","usag","user,","whether"],"firmwareapi/pycom/network/bluetooth/":["#","%","%x'","&","'heart","(apple'","(bit","(ble)","(bt_o):","(char.properties()","(commonli","(gap)","(hint:","(in","(low","(mac,","(p12)","*",",","...)","0","0,","1)","10","16","20","31","4","6","=","==",">","accept","access","act","addr_typ","addr_type,","address","adv","adv:","adv_typ","adv_type,","advertis","advertised.","advertisement.","advertisements,","advertisements.","advertiser:","advertising.","allow","alway","amount","antenna","antenna,","antenna.","antenna=none)","are:","arg","arg=none)","argument","argument.","arguments:","ascii","avail","available.","background.","basic","below","between","bit","ble","block","bluetooth","bluetooth()","bluetooth,","bluetooth.adv_128service_data,","bluetooth.adv_128srv_cmpl,","bluetooth.adv_128srv_part,","bluetooth.adv_16srv_part,","bluetooth.adv_32service_data,","bluetooth.adv_32srv_cmpl,","bluetooth.adv_32srv_part,","bluetooth.adv_adv_int,","bluetooth.adv_appearance,","bluetooth.adv_dev_class,","bluetooth.adv_flag,","bluetooth.adv_manufacturer_data","bluetooth.adv_manufacturer_data)","bluetooth.adv_name_cmpl)","bluetooth.adv_name_cmpl))","bluetooth.adv_name_cmpl,","bluetooth.adv_name_short,","bluetooth.adv_service_data,","bluetooth.adv_t16srv_cmpl,","bluetooth.adv_tx_pwr,","bluetooth.advertise([enable])","bluetooth.advertise(true)","bluetooth.bl","bluetooth.callback(trigger=bluetooth.client_connect","bluetooth.callback(trigger=none,","bluetooth.char_notify_ev","bluetooth.char_read_event,","bluetooth.char_write_event,","bluetooth.client_connected,","bluetooth.client_connected:","bluetooth.client_disconnect","bluetooth.client_disconnected,","bluetooth.client_disconnected:","bluetooth.conn_adv,","bluetooth.conn_dir_adv,","bluetooth.connect('112233eeddff')","bluetooth.connect(mac_addr)","bluetooth.deinit()","bluetooth.disc_adv,","bluetooth.disconnect_client()","bluetooth.events()","bluetooth.ext_","bluetooth.ext_ant.","bluetooth.get_adv()","bluetooth.get_advertisements()","bluetooth.init(id=0,","bluetooth.int_ant,","bluetooth.isscanning()","bluetooth.isscanning():","bluetooth.new_adv_event,","bluetooth.non_conn_adv,","bluetooth.prop_auth,","bluetooth.prop_broadcast,","bluetooth.prop_ext_prop","bluetooth.prop_indicate,","bluetooth.prop_notify,","bluetooth.prop_read):","bluetooth.prop_read,","bluetooth.prop_write,","bluetooth.prop_write_nr,","bluetooth.public_addr,","bluetooth.public_rpa_addr,","bluetooth.random_addr,","bluetooth.random_rpa_addr","bluetooth.resolve_adv_data(adv.data,","bluetooth.resolve_adv_data(data,","bluetooth.scan_rsp","bluetooth.service('abc123')","bluetooth.service(uuid,","bluetooth.set_advertisement(*","bluetooth.set_advertisement(name=\"advert\",","bluetooth.set_advertisement(name='lopy',","bluetooth.start_scan(","bluetooth.start_scan(10)","bluetooth.start_scan(20)","bluetooth.start_scan(timeout)","bluetooth.stop_scan()","bluetoothserverservice.","board","bool","both","break","bt","bt.connect(adv.mac)","bt.get_adv()","bt.resolve_adv_data(adv.data,","bt.start_scan(","bt_o.events()","byte","bytes:","cach","call","call.","callback","callback.","case","central","char","char.read()))","characterist","chars:","class","classic","clear","client","client.","close","combined):","commun","complet","configur","configuration.","conn","conn.disconnect()","conn.services()","conn_cb","connect","connected\")","connections.","constant","constrained,","constructor","contain","contain.","control","convert","creat","current","currently,","data","data)","data.","data_typ","data_type)","def","default","design","details.","develop","devic","device\")","device,","device.","disabl","disconnected\")","driver","dure","easi","eitherbluetooth.int_ant,","elapses.","elif","else:","enabl","energi","event","events.","events:","exampl","example:","examples:","except:","execut","extern","fails.","fals","fifo","fifo.","flag","flow","follow","free","fro","function","gap","gatt","gattcconnection.","gener","get","get_adv()","given","handler","handler=conn_cb)","handler=none,","here)","hexadecim","ibeacon","ibeacons).","id","identifi","immediately,","immediately.","import","indefinit","init","initi","initialis","integ","intern","isprimari","isprimary=true,","it.","itself","it'","known","larg","last","left","ling","list","listen","long","low","mac","mac_addr","manufactur","manufacturer_data","manufacturer_data=\"lopy_v1\")","manufacturer_data=none,","maximum","messag","message.","method","method,","method.","methodolog","mfg_data","mfg_data:","mobil","mode","mode.","mode:","mode=bluetooth.ble,","mode=pin.out)(true)","module,","module.","more","name","name=none,","nbr_char","nbr_chars=1,","network","network.bluetooth(id=0,","new","none","none.","noth","number","object","object,","object.","occur","occurs.","oem","on","one.","ongo","open","option","order","otherwise.","output","p12","param","pars","part","particular","pass","payload","pc","perform","peripher","pin","pin('p12',","pin.","platforms).","power).","power,","present,","present.","primari","print(\"client","print(\"error","print('char","print('read","print(bluetooth.resolve_adv_data(adv.data,","print(ubinascii.hexlify(mfg_data))","prior","process","process.","profil","progress.","properti","provid","pycom","quick","radio","radio.","rate':","read","receiv","received.","registri","request","resolv","resolve_adv_data()","resourc","retriev","return","role","rssi","rssi,","same","scan","scanning.","second","section","see","seen","select","send","sent","server","server.","servic","service.","service.characteristics()","service.uuid())","service_data","service_data=none,","service_uuid","service_uuid=b'1234567890123456')","service_uuid=none)","services:","set","set_advertisement()","shown","sign","signal","simultan","small","space","specif","specifi","start","start=true)","stop","strength","string","structure:","subset","succe","support","take","things.","time","time.sleep(0.050)","timeout","tri","trigger","triggered.","true","true:","try:","tupl","type","type(service.uuid())","type.","type:","types,","ubinascii","ubinascii.hexlify(adv.mac)","until","us","usag","usage:","used,","used.","uuid","valu","value.","variou","won't","work","zero.","{}","{}'.format(char.uuid(),","{}'.format(service.uuid()))","|"],"firmwareapi/pycom/network/bluetooth/gatt.html":["(att),","(the","advertis","alreadi","att","attribut","between","bluetooth","broken","call","case,","characterist","characteristics.","client","come","commun","concept","connect","data","defin","definitions,","devic","devices,","disconnected.","each","energi","establish","exclusive;","gap.","gatt","gener","gone","hold","i.e.","import","it'","known","lookup","low","made.","manag","mean","on","onc","phone/tablet),","process","profil","protocol","relat","remain","rememb","request","send","server","server,","server.","servic","services,","stand","stop","store/manag","table.","through","time.","two","until","us","way"],"firmwareapi/pycom/network/bluetooth/gattcconnection.html":["#","(commonli","(server)","1)","=","addr","adv","adv:","again","alreadi","around","assum","ble","bluetooth","bluetooth()","bluetooth.connect(adv.mac)","bluetooth.get_adv()","bluetooth.start_scan(","break","class","client","close","connect","connection.","connection.disconnect()","connection.isconnected()","connection.services()","contain","continu","data","devic","example:","except:","fals","gatt","gattcconnect","gattcservic","import","initi","known","list","master","master,","method","network","none","none.","object","open","open.","otherwis","otherwise.","perform","peripher","phone/tablet/pc).","print(\"connect","print(service.uuid())","print(services)","receiv","request","respons","return","scan","search","server,","servic","services:","slave.","start","still","succeeds.","transact","true","true:","try:","ubinascii","until","{}\".format(ubinascii.hexlify(adv.mac)))"],"firmwareapi/pycom/network/bluetooth/gattccservice.html":["128","16","32","allow","bit","ble","byte","call","case","categoris","characterist","characteristics,","characteristics.","chunk","class","client","connect","contain","control","data","each","fals","follow","gattccharacterist","gattcservic","id","instanc","integer,","known","list","long","method","multipl","numer","object","object.","one.","otherwise.","over","perform","peripher","primari","request","return","servic","service.","service.characteristics()","service.instance()","service.isprimary()","service.uuid()","services.","specif","succeeds.","true","uniqu","up","us","uuid","uuid.","uuids,","valu"],"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":["(though","0.","128","16","3","32","accelerometer,","accept","allow","arg","arg=none)","argument","array","axi","bit","bluetooth.char_notify_event.","byte","callback","callback.","case","characterist","characteristic,","characteristic.","characteristic.callback(trigger=none,","characteristic.instance()","characteristic.properties()","characteristic.read()","characteristic.uuid()","characteristic.value()","characteristic.write(b'x0f')","characteristic.write(value)","class","client.","concept","constant","contain","data","data,","details.","ed","encapsul","etc.).","execut","follow","function","gatt","gattccharacterist","get","given","given,","gps,","handler","handler=none,","hasn't","id","indic","instanc","integ","integer,","latitud","local","long","longitud","manag","method","more","noth","notif","now","object","object.","own","pass","point","properti","read","regist","relat","repres","request","return","section","see","send","server","server.","service.","singl","smallest","store","such","together.","trigger","triggered.","used.","uuid","uuids,","valu","value.","without","write","written.","x/y/z","yet,"],"firmwareapi/pycom/network/bluetooth/gattsservice.html":["&","*",",","16","act","allow","alreadi","are:","argument","att","byte","call","categoris","characterist","characteristic.","characteristics,","characteristics.","chunk","class","combin","configur","control","creat","data","data,","definitions.","devic","each","ed","flags.","follow","gatt","gattscharacteristic.","gattsservic","hold","id","initi","integ","integer,","known","long","lookup","master","method","mode,","multipl","new","numer","object","object.","over","peripher","permiss","permissions,","previous","properti","properties,","properties.","request.","return","server","servic","service.","service.characteristic('temp',","service.characteristic(uuid,","service.start()","service.stop()","services.","set","slave","specif","start","started.","stop","string","take","uniqu","up","us","uuid","uuid.","valu","value)","value.","value=25)"],"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":["#","&","(bt_o):","(though","+=","0","0xf1:","1","123","3","=","accelerometer,","advertis","allow","are:","arg","arg=none)","argument","array","axi","bit","bluetooth","bluetooth()","bluetooth.advertise(true)","bluetooth.callback(trigger=bluetooth.client_connect","bluetooth.char_read_ev","bluetooth.char_write_event.","bluetooth.char_write_event:","bluetooth.client_connected:","bluetooth.client_disconnected,","bluetooth.client_disconnected:","bluetooth.service(uuid=b'1234567890123456',","bluetooth.set_advertisement(name='lopy',","bt_o.events()","byte","call","call.","callback","callback.","char1_cb_handler(chr):","char1_read_count","char2_cb","char2_read_count","characterist","characteristic,","characteristic.","characteristic.callback(trigger=none,","characteristic.events()","characteristic.value()","characteristic.value(123)","characteristic.value([value])","characteristics.","chr.events()","chr1","chr2.callback(trigger=bluetooth.char_read_event,","class","clear","concept","conn_cb","connected\")","contain","creat","data","data,","def","device:","disconnected\")","elif","else:","encapsul","etc.).","event","events.","exampl","execut","flag","follow","function","gatt","gattscharacterist","get","given,","global","gps,","handler","handler=char2_cb_handler)","handler=conn_cb)","handler=none,","identifi","implement","import","integ","integer,","isprimary=true)","last","latitud","longitud","manag","method","network","noth","object","object.","occur","occurs.","own","pass","point","print(\"client","print(\"writ","relat","request","return","section.","seen","server","servic","service_uuid=b'1234567890123456')","set","singl","smallest","srv1","srv1.characteristic(uuid=b'ab34567890123456',","string","such","take","trigger","triggered.","used.","valu","value=5)","x/y/z","{}\".format(chr.value()))","|"],"firmwareapi/pycom/network/lora.html":["#","&","(0","(0),","(1)","(1),","(2),","(2):","(3)","(4).","(a","(activ","(data,","(dev_addr,","(dev_eui,","(e.g.","(even","(if","(in","(join","(lora.lora).","(lora.lora):","(may","(onli","(or","(over","(rx_timestamp,","(so_*","*",",",",region=lora.eu868,",",timeout=none,","...)","0","0,","0.","0x02,","0x03]))","1","1..254","1.0.2","100)","12.","12:","14","15","2","2,","2.","20","254","255","3","3]))","4","5","5)","50%","7","7).","71","8","8.","863000000","868","868mhz","870000000","902000000","915","915mhz","928000000","=","abp","accept","accord","ack","activ","activation)","activation:","adapt","add","add.","addit","address","adr","adr,","adr=false,","again.","air","allow","alreadi","alway","always_on","ambl","antenna","antenna),","any)","app_eui","app_eui,","app_key","app_key)","app_key),","app_swkey","app_swkey))","app_swkey).","applic","appropri","are:","arg=none)","argument","arguments,","around","asia","attempt","australia","auth,","auth:","auth=(app_eui,","auth=(dev_addr,","auth=(dev_eui,","authent","automat","automatically,","band","band,","band.","bandwidth","bandwidth:","bandwidth=lora.bw_125khz,","batteri","be","befor","below","below:","between","binascii.unhexlify('00000005'))[0]","bind()","bit","block","but,","byte","call","callback","callback.","card.","case","centr","chang","changed.","channel","channel,","channel.","check","class","class.","class:","clear","code","coding_r","coding_rate=lora.coding_4_5,","come","command","complet","completes.","compliant","configur","configuration.","confirm","connect","constant","constructor","contain","counters,","creat","current","custom","cycl","cycle.","damag","data","data.","db","dbm).","dbm.","deepsleep","deepsleep.","def","default","defin","demonstr","desir","destin","dev_addr","dev_eui","devic","device.","device:","device_class","device_class=lora.class_a)","differ","directly.","do:","downlink","dr:","dr=none)","dr_max)","dr_max:","dr_max=6)","dr_min,","dr_min:","dr_min=5,","driver","enabl","end","ends,","ensur","enter","etc)","etc.).","eu","eu868,","europ","event","exampl","example,","example:","examples,","examples.","examples:","except","extern","factor","factor,","factor.","fals","false)","false.","fipy.","float","float).","follow","form:","frequenc","frequency,","frequency:","frequency=868000000,","function","given","given,","goe","hand,","handl","handler","handler=lora_cb)","handler=none,","have","here","hold","hz","id","ignor","immedi","import","improp","includ","incom","index","index.","index:","indic","inform","init","initi","initialis","integers.","intern","inversion.","iq","is:","join","joined.","joined...')","keys,","khz.","know","last","last).","level","level,","level.","listen","lopi","lora","lora(mode=lora.lorawan,","lora.abp","lora.abp.","lora.add_channel","lora.add_channel(index,","lora.add_channel(index=0,","lora.always_on,","lora.as923","lora.as923,","lora.au915","lora.au915,","lora.bandwidth()","lora.bandwidth([bandwidth])","lora.bandwidth(lora.bw_125khz)","lora.bw_125khz","lora.bw_125khz,","lora.bw_250khz","lora.bw_250khz,","lora.bw_250khz.","lora.bw_500khz","lora.bw_500khz.","lora.callback(trigger,","lora.callback(trigger=(lora.rx_packet_ev","lora.class_a","lora.class_a,","lora.class_c","lora.class_c.","lora.coding_4_5","lora.coding_4_5,","lora.coding_4_6","lora.coding_4_6,","lora.coding_4_7","lora.coding_4_7,","lora.coding_4_8","lora.coding_4_8.","lora.coding_rate()","lora.coding_rate([coding_rate])","lora.coding_rate(lora.coding_4_5)","lora.eu868","lora.eu868,","lora.events()","lora.events().","lora.frequency()","lora.frequency(868000000)","lora.frequency([frequency])","lora.has_joined()","lora.has_joined().","lora.has_joined():","lora.init(mode,","lora.init(mode=lora.lora,","lora.init(mode=lora.lorawan)","lora.ischannel_free(","lora.ischannel_free(rssi_threshold)","lora.join(activation,","lora.join(activation=lora.abp,","lora.join(activation=lora.otaa,","lora.lora","lora.lora,","lora.lorawan","lora.lorawan.","lora.mac()","lora.nvram_erase()","lora.nvram_restore()","lora.nvram_save()","lora.otaa","lora.otaa,","lora.power_mode([power_mode])","lora.preamble()","lora.preamble([preamble])","lora.preamble(lora.coding_4_5)","lora.remove_channel()","lora.remove_channel(index)","lora.rx_packet_ev","lora.rx_packet_event,","lora.rx_packet_event:","lora.set_battery_level(127)","lora.set_battery_level(level)","lora.sf()","lora.sf(7)","lora.sf([sf])","lora.sleep","lora.sleep.","lora.sleep:","lora.stats()","lora.tx_failed_ev","lora.tx_onli","lora.tx_only,","lora.tx_packet_ev","lora.tx_packet_event),","lora.tx_packet_event,","lora.tx_packet_event:","lora.us915","lora.us915.","lora_cb(lora):","loraeu868.","lorawan","lorawan.","lower","mac","make","match","maximum","maximum.","mean","measur","memori","memory.","messag","method","method.","mhz","microsecond","millisecond","minimum","mode","mode)","mode,","mode.","mode:","modul","module:","ms).","name","need","network","network.","network.lora(id=0,","new","nois","non","note","number","nvram_sav","nwk_swkey","nwk_swkey,","object","object.","occur","on","one.","option","option.","optional.","optname,","order","ored):","otaa","otherwis","otherwise.","out","packet","packet.","packets).","param","paramet","performed.","perman","personalis","personalisation)","pick","place.","pleas","point","port","port)","possibl","power","power_mod","power_mode=lora.always_on,","pre","preambl","preamble=8,","precis","precision.","previous","print('lora","print('not","print(data)","privat","procedure:","processor","program","provid","public","public,","public=true,","radio","radio.","rais","rang","rate","rate.","rate:","ratio","raw","receiv","received')","received,","received.","received...","region","region=lora.eu868)","regions:","registri","relev","remov","removed,","replac","request","request.","restor","restrict","retri","retriev","return","rssi","rssi,","rssi_threshold","rx","rx_iq","rx_iq=false,","rx_timestamp","s","s.bind(1)","s.close()","s.recv(128)","s.recv(64)","s.recvfrom(128)","s.send('hello')","s.send(bytes([0x01,","s.send(bytes([1,","s.setblocking(false)","s.setblocking(true)","s.setsockopt(socket.sol_lora,","s.settimeout(5.5)","same","save","saved.","second","seconds.","see","seen","select","send","sending/receiv","sent","sent')","set","sf","sf=12)","sf=7,","sfrx","sfrx,","sftx","sftx,","signal","singl","sleep","snr","snr,","socket","socket.bind(port_number)","socket.close()","socket.recv(bufsize)","socket.recvfrom(bufsize)","socket.send(bytes)","socket.setblocking(flag)","socket.setsockopt(level,","socket.settimeout(value)","socket.so_confirmed,","socket.so_dr,","socket.sock_raw)","socket.socket(socket.af_lora,","soon","source.","specif","specifi","specification:","specified,","spread","stack","stack.","standard","state","statu","status,","store","strength","struct","struct.unpack(\">l\",","subsystem","support","symbol","symbols.","sync","take","tell","therefor","therefore,","there'","this.","those","time","time.sleep(2.5)","timeout","timeout:","timeout=0)","timestamp","transmiss","transmission.","transmissions,","transmit","transmitted.","trigger","true","true)","true,","tupl","tx","tx_counter","tx_counter,","tx_frequenc","tx_frequency)","tx_iq","tx_iq=false,","tx_onli","tx_power","tx_power,","tx_power.","tx_power=14,","tx_retri","tx_retries=1,","tx_time_on_air","tx_time_on_air,","tx_trial","tx_trials,","type","ubinascii","ubinascii.unhexlify('00000005'))[0]","ubinascii.unhexlify('11b0282a189b75b0b4d2d8c7fa38548b')","ubinascii.unhexlify('2b7e151628aed2a6abf7158809cf4f3c')","ubinascii.unhexlify('ada4dae3ac12676b')","unit","until","us","us.","us915.","usage:","used.","valu","value)","values.","values:","variou","version","version.","volatil","wait","way","way:","ways:","whenev","where:","window","windows,","without","won't","word.","work","zero)","|"],"firmwareapi/pycom/network/sigfox.html":["#","&","'","'true'","(868","(and","(devic","(e.g.","(europe)","(sipy)","(so_*","(thi","(uplink_frequency_hz,","*","+","+14dbm","+22dbm",",",".","...)","1","1')","10,","100):","11,","12","12]))","1:","2","2')","2,","20","2:","3,","3]))","4","4,","5","5,","6,","64","64.","7,","8","8,","863","9,","912","928","=","achiev","address","africa.","allow","alway","amount","antenna","antenna),","api","applic","are:","area","argentina.","argument","australia,","automat","await","band","band,","base","befor","below:","between","bi","binari","bit","block","blocking,","boolean","both","brazil.","buffer","byte","bytes.","call","capabl","card.","care","case","channel","channel.","class","close","code","colombia","come","commun","communication.","complet","configur","configuration.","connect","constant","constructor","contain","convert","correct","creat","cycl","damag","data","data,","default","defin","delay","devic","device)","device.","devices,","devices.","differ","directional,","disabl","done","down","downlink","downlink_frequency_hz)","driver","due","duti","e.g.","empti","enabl","encrypt","ensur","etc.)","etc.).","europe,","exampl","example:","examples:","exclus","exist","expect","false)","fcc","fipy.","first","flag.","flavours:","follow","form:","frequenc","frequency,","frequency=868000000)","frequency=912000000)","frequency=none)","fsk","fsk,","fsk.","fulfilled.","get","given","hardwar","hexidecim","hong","however,","human","i.e.:","id.","import","indic","init","initialis","integ","integer.","japan.","key","kong,","last","life","like:","limitations).","limitations,","lopi","low","mac","macro","make","maximum","mean","messag","message.","method","method.","mexico","mhz","mhz)","mhz.","minimum","mode","mode.","mode:","modul","modulation.","module:","narrow","necessari","need","network","network,","network.","network.sigfox(id=0,","new","normal","note:","object","object.","often),","oman","oper","option.","optname,","out","pac.","packet","packet.","packets.","param","pass","payload","payload,","piec","pleas","point","power","print(s.recv(64))","print(ubinascii.hexlify(sigfox.mac()))","procedur","processor","proper","protocol","provid","public","public_key","pycom","quick","radio","radio.","range(1,","rcz","rcz1","rcz2","rcz3","rcz4","rcz4.","rcz=sigfox.rcz1)","rcz=sigfox.rcz1,","readabl","real","receiv","region","rememb","remot","representation.","request","requir","reset","restrict","return","run","s","s.recv(32)","s.recv(64)","s.send('')","s.send('devic","s.send('hello","s.send('hello')","s.send(bytes([1,","s.setblocking(true)","s.setsockopt(socket.sol_sigfox,","s.settimeout(5.0)","same","second","see","seen","select","send","sending/receiv","sending/receiving.","sent","servers.","set","setsockopt()","sigfox","sigfox(mode=sigfox.fsk,","sigfox(mode=sigfox.sigfox,","sigfox,","sigfox.frequencies()","sigfox.fsk","sigfox.fsk.","sigfox.id()","sigfox.init(mode=sigfox.sigfox,","sigfox.mac()","sigfox.pac()","sigfox.public_key()","sigfox.public_key([public])","sigfox.public_key(true)","sigfox.rcz1,","sigfox.rcz2,","sigfox.rcz3,","sigfox.rcz4","sigfox.rcz4.","sigfox.rssi()","sigfox.sigfox","sigfox.sigfox,","sigfox.sigfox.","sign","signal","singapore,","singl","sipi","size","socket","socket,","socket.","socket.close()","socket.recv(bufsize)","socket.send(bytes)","socket.setblocking(flag)","socket.setsockopt(level,","socket.settimeout(value)","socket.so_bit,","socket.so_oob,","socket.so_rx,","socket.sock_raw)","socket.socket(socket.af_sigfox,","someth","south","specifi","standard","state","str(i))","strength","string","string,","support","sure","symbol","taiwan,","take","technology.","test","therefore,","this,","time","time.sleep(1)","timeout","transmissions.","true","true)","true:","tupl","two","tx","ubinascii","ultra","unb","until","up","uplink","upon","us","usa,","usag","valu","value)","values:","version","wait","way:","wide","without","work","zealand,","zones:"],"firmwareapi/pycom/network/lte.html":["#","(connect","(i.e.","(or","(same","...)","1.4","12,","13,","2.5","20","200","28.","2g/gprs,","3,","375","3gpp","4,","5","6","60","=","abov","access","activ","address","address.","are:","argument","around","at&t,","attach","authoris","automatically,","avail","band","band=none)","batteri","be","befor","between","both","call","card.","carrier","carrier,","carrier=none)","cat","categori","cells,","cellular","channel","check","cid","cid=1)","cid=1.","cid=3.","class","command","compat","completely.","configur","configuration.","connect","connected),","constructor","consumpt","coverag","creat","current","data","deepsleep.","def","defin","deinit()","deploy","design","detach","develop","devic","differ","directli","disabl","done","enabl","end","enter","example:","fals","featur","file.","fipi","fipy.","firmwar","flash","found","fsm","full","function","functionality.","gener","given.","gpi","gpy/fipi","hardwar","here.","iccid","id)","id.","imei","import","important:","init","insert","instance,","instruct","iot","iot,","ip","it'","kbp","khz","known","licens","life","life,","life.","line","long","longer","low","lte","lte()","lte(carrier=\"verizon\")","lte.attach(*,","lte.attach(band=13)","lte.connect(*,","lte.connect(cid=3)","lte.deinit()","lte.dettach()","lte.disconnect()","lte.iccid()","lte.imei()","lte.init(*,","lte.isattached()","lte.isattached())","lte.isattached():","lte.isconnected()","lte.isconnected():","lte.reset()","lte.send_at_cmd('at+cereg?')","lte.send_at_cmd(cmd)","lte.send_at_cmd(cmd).split('\\r\\n')","m","m/nb","m1","m1:","make","mani","manual","method","mhz","minimum.","mobil","mobility.","mode","modem","modem.","modul","monarch","move","name.","nb","nb1","need","network","network.","network.lte(id=0,","networks.","new","none)","note","note:","now","number","object","object.","obtain","obtained.","offer","older","on","oper","optimis","option","order","other","otherwise.","outperform","param","pars","paus","pdf","perform","phi","pleas","possibl","power","pretti","previou","print('attaching...')","print('connecting...')","print(line)","printing:","process","protocol","protocol.","protocols:","provid","pycom'","radio","range.","raw","reboot.","reconnect.","reduc","registr","request","requir","reset","respons","response:","restrict","resum","return","scan","scanned.","second","seconds.","see","send","send_at_cmd_pretty('at!=\"fsm\"')","send_at_cmd_pretty('at!=\"showphy\"')","send_at_cmd_pretty(cmd):","sequan","session","session.","set","sever","share","shutdown","sim","similar","size","socket","specif","specifi","specific,","specified,","spectrum,","speed.","standard","standard.","standards.","start","statu","string","subsystem.","such","support","switch","system","take","telstra","throughput","throughput.","time","time.","time.sleep(0.5)","true","two","ultra","up","up.","uplink","us","usual...","valu","veri","verizon","verizon,","verizon:","wait","whole","work","world."],"firmwareapi/pycom/aes.html":["#","(16","(advanc","(ae","(byte","(iv)","(never","(see","*","+",",","...","128","128),","128,","16","192),","192,","24","256","256)","32","=","ae","aes(key,","aes.mode_cbc:","aes.mode_cfb","aes.mode_cfb,","aes.mode_cfb.","aes.mode_cfb:","aes.mode_crt.","aes.mode_ctr.","aes.mode_ctr:","aes.mode_ecb","aes.mode_ecb.","aes.mode_ecb:","aes.segment_128","aes.segment_128:","aes.segment_8","aes.segment_8,","alway","appli","are:","argument","articl","associ","avoid","b'notsuchsecretkey'","bit","bits.","block","book.","byte","bytes)","bytes.","chain","chaining.","cipher","cipher.","cipher.decrypt(msg[16:])","cipher.encrypt(b'attack","ciphertext","class","code","constant","constructor","counter","counter,","creat","crypto","crypto.getrandbits()","crypto.getrandbits(128)","ctr","data","dawn')","decrypt","decryption.","default","differ","each","electron","encrypt","esp32","exampl","feedback.","fix","gener","hardwar","hide","ignor","implement","import","in.","info)","initialis","initialisation.","issues,","it)","iv","iv)","iv,","key","key.","length","long.","messag","messages.","method","mode","mode,","mode.","module.","more","msg","msg[:16])","never","nist.","number","object","origin","paramet","pattern","plaintext","print(original)","process","properli","purpose.","quick","random","required.","reus","reused.","same","secret","secur","segment","segment_s","segment_size)","sent","set","side","simplest","size","somewher","standard)","standardis","stream","string)","support","symmetr","two","ucrypto.aes(key,","ucrypto.decrypt()","ucrypto.encrypt()","uniqu","us","usag","use.","valu","vector","vector.","well","work"],"firmwareapi/pycom/pycom.html":["\"","\"/sd/appimg.bin\"","\"rb\")","#","%","'/sd')","(enabl","(lopi","(true","+=","0:","0x00ff00","10)","100)","24","25)","32","4096","5000","5000m","8","=",">","accept","active.","allow","alreadi","ap","appimg","applic","arbitrari","area","area.","avoid","between","bit","bits.","block","blocksiz","blue,","boolean","boot","boot,","break","bright","buffer","bytearray(blocksize)","call","card","chunk","class.","color","colour","come","const(4096)","contain","control","cycles.","data","default","devic","devices,","dht11/dht22/am2302","disabl","disabled)","durat","each","effect","else:","enabl","end=\"\")","entir","eras","exampl","example)","example:","exist","extern","f.readinto(buffer)","f:","false).","false,","featur","feed","file","file,","firmwar","flag","flag.","flash.","follow","ftp.","function","get","given","green","green.","heartbeat","heartbeat.","here","hold","imag","import","inp","instance,","instead","integ","intern","it'","key","led","led.","light","list","machin","make","memori","memoryview(buffer)","method","microsecond","milliseconds.","minimum","mode.","mode=pin.open_drain)","modul","moment.","mount","mount(sd,","ms","ms.","mv","need","new","next","non","none.","note,","nvram","object,","obvious","occur","onc","open(appimg,","open_drain","os","ota_finish","ota_finish()","ota_finish().","ota_start()","ota_start(),","ota_start,","ota_write(buffer),","ota_write(mv[:chunk])","ota_write,","part","pass","perform","perman","persist","pin","pin(\"g7\",","pin(0)","pin(1)","pin.","power","preserv","print(\"\\r%7d","process.","protocol,","puls","pulses_get","pulses_get(pin,","pycom","pycom.heartbeat()","pycom.heartbeat([enable])","pycom.heartbeat(false)","pycom.heartbeat(true)","pycom.heartbeat_on_boot([enable])","pycom.nvs_erase(key)","pycom.nvs_erase_all()","pycom.nvs_get('count')","pycom.nvs_get(key)","pycom.nvs_set('count',","pycom.nvs_set('temp',","pycom.nvs_set(key,","pycom.ota_finish()","pycom.ota_start()","pycom.ota_write(buffer)","pycom.pulses_get(pin,","pycom.rgbled(0xff00)","pycom.rgbled(color)","pycom.wdt_on_boot()","pycom.wdt_on_boot([enable])","pycom.wdt_on_boot(true)","pycom.wdt_on_boot_timeout()","pycom.wdt_on_boot_timeout(10000)","pycom.wdt_on_boot_timeout([timeout])","pycom.wifi_on_boot()","pycom.wifi_on_boot([enable])","pycom.wifi_on_boot(true)","quick","raw","read","reboots.","receiv","recommended.","reconfigur","red","red,","regularli","repres","reset","reset,","reset.","return","rgb","run","scan","script","sd","sd()","sensor","seri","server","set","set,","shall","signific","size","size,","size=0","sizes.","sleep_m","sleep_ms(20)","specif","specifi","ssid","start","state","stop","store","such","suitabl","system.","take","tell","termin","though","time","timeout","timeout)","transit","true,","true:","tuples,","until","up","updat","update.","us","usag","valu","value)","value.","veri","via","volatil","wdt","wdt_on_boot_timeout.","wifi","within","without","wlan","written","written,","xxx"],"firmwareapi/micropython/":["\"micro","avail","built","contain","core","devices.","directori","drop","example,","fallback","file","first","fit","follow","found,","found.","function","ified\"","import","intend","it'","json","json.pi","librari","libraries,","library.","list","load","micropython","micropython.","modul","module.","name","name,","name.","non","noth","overridden","packag","path.","philosophi","provid","pycom","python","replac","search","specif","standard","u","ujson"],"firmwareapi/micropython/micropython.html":["(a","(e.g.","(eg","*","+","1","1)","100","3","=","abov","absolut","access","activ","again.","alloc","amount","argument","around","attempted.","avail","be","begin","block","boot.pi","both","buffer","byte","bytes).","c","c,","c.","call","captur","case","charact","code","compil","comput","const","const(123)","const(2","const_i","const_x","constant","correspond","cpython","creat","ctrl","current","declar","default","dependent,","depth","differ","directli","disabl","dure","emerg","entir","except","exception.","execution,","execution.","express","extra","fail","follow","follows:","free.","function","give","given","global","good","hand,","handler)","heap","heap.","heap_lock()","heap_unlock()","hidden,","i.e.","implement","import","in.","includ","incom","increase,","indic","inform","integ","intern","interrupt","it.","keyboardinterrupt","level","level.","lock","main","main.py)","mainli","make","memori","memory.","memoryerror","method","micropython","micropython,","micropython.alloc_emergency_exception_buf(size)","micropython.const(expr)","micropython.heap_lock()","micropython.heap_unlock()","micropython.kbd_intr(chr)","micropython.mem_info([verbose])","micropython.opt_level([level])","micropython.qstr_info([verbose])","micropython.stack_use()","mode","modul","multipl","name","nested,","none.","normal","number","occur","optimis","otherwis","out","outsid","parser","part","particularli","pass","pattern.","place","points.","prevent","print","printed.","provid","purposes.","rais","ram","recognis","repl,","repres","restor","return","row","run","same","script","scripts,","set","situations.","size","stack","start","still","stream","string","strings.","subsequ","take","therefor","time","traceback","under","underscor","unlock","up","us","usag","use.","used.","useful,","usual","valu","variabl","variable,","verbos","way","within","written"],"firmwareapi/micropython/uctypes.html":["\"arr\":","\"arr2\":","\"b0\":","\"b1\":","\"bf\"),","\"bitf0\":","\"descriptor\"","\"field_name\":","\"foreign","\"ptr\":","\"ptr2\":","\"sub\":","(2,","(and","(correspond","(doesn't","(e.g.","(encod","(for","(foreign","(in","(it'","(note:","(or","(pack","(python","(see","(thi","(typenam","(uctypes.array","(uctypes.ptr","*","*.","0","0,","0.","0}),","1).","1,","2","2),","2,","3","8","[0]","[]","abi","abi,","abov","above,","above.","access","actual","address","address,","address.","aggreg","align","alloc","allow","allows,","alternatively,","alway","anticip","api","are:","argument","array","array,","array.","assign","associ","avoid","baremet","base","basic","be","behind","below).","bf_len","bf_po","big","binari","bit","bit,","bitfield","bitfield).","bitfield,","bitfields:","bits,","both","buffer","byte","bytearray","bytes)","bytes,","bytes.","bytes_at()","c","c.","call","captur","care","chang","class","come","complex","concis","conform","constructor.","contain","content","copi","correspond","count","cpython'","creat","ctype","current","currently,","data","data,","datasheet","decreas","defin","defines).","depend","dereferenc","dereference,","describ","descriptor","descriptor,","detail","dictionari","dictionary),","differ","different,","disabl","dot","duplic","each","ed","effectively,","element","encod","endian","endianness,","even","exactli","exampl","example,","except","explicit","extra","extract","familiar","ffi","field","field).","field.","fields.","file","first","flag","float)","follow","function","function,","function.","further","gener","get","given","hardwar","i.e.","i/o","idea","identifi","immutable,","implement","import","independ","individu","instanc","instanti","instead","integ","interface\"","interface)","intermedi","interrupt).","it'","key","languag","larg","later,","layout","layout_type=native)","layouts,","lead","length","limit","littl","lookup","mani","mcu/soc.","mcu_registers.peripheral_a.register1,","mean","memori","memory,","micropython","micropython.","modul","modules,","my_struct.substruct1.field1.","name","nativ","need","nest","network","non","normal","normalis","notation:","note","number","object","object,","object.","occupi","offset","offset,","on","oper","operator,","optimis","origin","pack","parallel","particular","particular,","pass","peripheral,","peripheral_a.register0.","peripheral_a.register1.","peripheral_a.register[0]","point","pointer","pointer,","posit","positions,","possibl","power","predefin","prefix","primit","produc","prohibited).","properti","protocol","ptr","python","read","readabl","recommend","recurs","refer","reference,","regist","registers,","rel","repres","requir","required),","respectively.","restrict","retain","return","returned).","right","rightmost","runs.","same","scalar","scale","second","semant","separ","shift","signific","similar","size","size)","size.","small","socket).","sources:","special","specif","standard","start","start.","streamlin","structur","structure\"","structure.","structures).","structures.","structures:","sub","subscript","sum","support","syntax","syntax,","system","system.","taken","target","them.","third","though","to.","too).","too,","tuple,","type","type,","type.","type:","types,","types:","uctyp","uctypes.addressof(),","uctypes.addressof(obj)","uctypes.bfuint16","uctypes.big_endian","uctypes.bytearray_at(addr,","uctypes.bytes_at(addr,","uctypes.little_endian","uctypes.n","uctypes.sizeof(struct)","uctypes.struct()","uctypes.struct(addr,","uctypes.uint32","uctypes.uint8","uctypes.uint8),","uint16","uint16,","uint16.","unlik","up,","us","usage,","ustruct","usual","valu","value,","value.","values.","variou","want","way","well","whose","within","without","words,","work","written","{","{\"b\":","|","})"],"firmwareapi/micropython/sys.html":["\">","\"big\").","\"bitness\"","\"micropython\"","#","(\"little\"","(1,","(32","(e.g.","(major,","(note","(or","(that","(v","+=","0","0)","1","16\",","31)","32","32\",","32:","64","64\"","7,","=",">",">>=","above,","actual","another.","appear","argument","attribut","attributes:","bare","baremet","bit","bit,","board","board,","board.","builtin","byte","case","check","code.","compar","comparisons.","compat","conform","constant","count","cpython","cpython.","current","default).","describ","detect","dictionari","differ","directly,","directori","distinguish","due","e.g.","else:","error","etc.).","except","exception.","exist","exit","file","file=sys.stdout)","follow","found","function","further","given","given,","hold","identifi","implement","implementation),","implementation.","import","includ","inform","input","instead","instead.","int","integ","ints.","it:","it'","languag","less","less)","lib.","linux.","list","load","long","mandat","max","maximum","method","micro),","micropython","micropython,","micropython.","minim","minimum","minor,","modul","modules.","more","more)","mutabl","name","nativ","need","note","number","object","object,","object;","on","on.","order","origin","os,","os/rto","output","peculiar","platform","platform,","port","ports).","ports,","positional;","print","program","pyboard","python","rais","recommend","refer","represent","run","search","simplifi","smaller","standard","start","still","stream.","string","string.","style","support).","supported.","sy","sys.argv:","sys.byteorder:","sys.exit(retval=0)","sys.implement","sys.implementation:","sys.maxs","sys.maxsize:","sys.modules:","sys.path:","sys.platform:","sys.print_exception(exc,","sys.stderr:","sys.stdin:","sys.stdout","sys.stdout:","sys.version:","sys.version_info:","system","systemexit","systemexit.","take","termin","thu","to,","traceback","traceback.print_exception(),","tupl","type","type,","underlyingly,","unlik","us","usual","v","v:","valu","value,","veri","version","vs","way","whether","with.","without"],"firmwareapi/micropython/uos.html":["'/sd')","(if","(in","(like","(not","(the","*",",","/","/flash","/sd","/sd.","0)","10","access","access.","alia","argument,","avail","be","befor","bits.","block","byte","bytes.","card","chang","change.","charact","constant","contain","content","creat","current","currently:","devic","device.","directori","directory.","drive","duplic","example:","exists)","file","file.","filesystem","filesystems.","firmwar","flash","follow","format","free","function","function.","given","group","hard","here.","id","implement","implemented,","inform","inod","intern","interpret","kib)","links.","list","metadata","method","method.","methods.","micropython","modification.","modul","mount","mount_point,","mounted.","n","new","new_path)","number","number.","object","object)","object.","order:","os.mount(sd,","otherwis","owner.","pass","path","path)","path,","path.","physic","point.","port","previous","protect","random","read()","readonly=false)","recent","releas","remov","remove()","renam","repl)","return","root","sd","separ","size","space","specif","specifi","st_atime:","st_ctime:","st_dev:","st_gid:","st_ino:","st_mode:","st_mtime:","st_nlink:","st_size:","st_uid:","statu","stream","sync","system,","termin","time","tupl","unmount","uo","uos.chdir(path)","uos.dupterm(stream_object)","uos.getcwd()","uos.getfree(path)","uos.listdir([dir])","uos.mkdir(path)","uos.mkfs(block_devic","uos.mount(block_device,","uos.remove(path)","uos.rename(old_path,","uos.rmdir(path)","uos.sep:","uos.stat(path)","uos.sync()","uos.uname()","uos.unlink(path)","uos.unmount(path)","uos.urandom(n)","urandom","us","user","valu","values,","version,","version.","write()","–"],"firmwareapi/micropython/array.html":["(the","2","append","array","array,","array.append(val)","array.array(typecode[,","array.extend(iterable)","b,","class","codes:","contain","content","creat","created.","d","depend","element","empti","end","f,","float","format","given","grow","h,","i,","information.","initi","it.","iter","iterable.","iterable])","l,","latter","method","more","new","point","provided,","python","q,","see","support","support).","type."],"firmwareapi/micropython/cmath.html":["(","+pi).","10","along","axis.","base","basic","branch","circle'","circumfer","cmath","cmath.cos(z)","cmath.e:","cmath.exp(z)","cmath.log(z)","cmath.log10(z)","cmath.phase(z)","cmath.pi:","cmath.polar(z)","cmath.rect(r,","cmath.sin(z)","cmath.sqrt(z)","complex","constant","cosin","cut","diamet","exponenti","float","form","function","logarithm","mathemat","method","modul","module.","modulu","natur","neg","number","numbers.","phase","phi)","phi.","pi,","point","polar","provid","r","rang","ratio","real","requir","return","returns,","root","sine","squar","support","tuple,","work","z,","z."],"firmwareapi/micropython/math.html":["(0.0,","(2**exp).","(m,","*","0","0),","0.","0.5","1.","10","2","2**e","==","absolut","base","basic","be","both","circle'","circumfer","complementari","constant","convert","cosin","decompos","degre","degrees.","diamet","e)","error","exactly.","exp(x)","exp)","exponent.","exponenti","finite.","float","floats,","fraction","function","gamma","holds.","hyperbol","infinite.","infinity.","integer,","integr","invers","logarithm","m","mantissa","math","math.acos(x)","math.acosh(x)","math.asin(x)","math.asinh(x)","math.atan(x)","math.atan2(y,","math.atanh(x)","math.ceil(x)","math.copysign(x,","math.cos(x)","math.cosh(x)","math.degrees(x)","math.e:","math.erf(x)","math.erfc(x)","math.exp(x)","math.expm1(x)","math.fabs(x)","math.floor(x)","math.fmod(x,","math.frexp(x)","math.gamma(x)","math.isfinite(x)","math.isinf(x)","math.isnan(x)","math.ldexp(x,","math.lgamma(x)","math.log(x)","math.log10(x)","math.log2(x)","math.modf(x)","math.pi:","math.pow(x,","math.radians(x)","math.sin(x)","math.sinh(x)","math.sqrt(x)","math.tan(x)","math.tanh(x)","math.trunc(x)","mathemat","method","modul","module.","natur","neg","number","numbers.","otherwis","part","point","posit","power","princip","provid","radian","radians.","ratio","relat","remaind","requir","return","root","round","same","sign","sine","squar","such","support","tangent","toward","true","tupl","two","valu","work","x","x)","x.","x/y.","y)","y.","y/x."],"firmwareapi/micropython/gc.html":["allocated,","allocated.","automat","avail","byte","collect","collection.","disabl","enabl","garbag","gc","gc.collect()","gc.collect().","gc.disable()","gc.enable()","gc.mem_alloc()","gc.mem_free()","heap","initi","manual","memori","method","number","ram","ram.","return","run","still","us"],"firmwareapi/micropython/ubinascii.html":["(i.e.","(in","addit","argument,","ascii","base64","between","binari","both","byte","convers","convert","cpython","data","differ","directions).","encod","form","format.","hexadecim","hexlify)","implement","invers","method","modul","representation.","return","sep","sep])","separ","string.","supplied,","ubinascii","ubinascii.a2b_base64(data)","ubinascii.b2a_base64(data)","ubinascii.hexlify(data[,","ubinascii.unhexlify(data)","us","values.","variou"],"firmwareapi/micropython/ujson.html":["(a",".read()","allow","between","contain","content","convert","correctli","data","document).","file","format.","formed.","fp","json","method","modul","obj","object","object.","pars","python","rais","repres","return","str","string","string.","support","ujson","ujson.dumps(obj)","ujson.load(fp)","ujson.loads(str)","valueerror"],"firmwareapi/micropython/ure.html":["$","(and","(which","({m,n}),","*","*?","+","+?",".","0","1)","?","??","[]","^","actual","advanc","against","alway","anchored).","are:","assertions,","charact","character.","characters.","class","compil","count","cpython","creat","debug","display","etc.","express","expression,","expression.","expressions).","extend","first","flag","group","groups,","happen","implement","individu","inform","instanc","match","match()","match,","match.group([index])","max_split=","method","methods.","modul","more","name","numer","object","object.","oper","operations.","posit","posix","rang","re","regex","regex.match(string)","regex.search(string)","regex.split(string,","regular","repetit","return","search","search()","set","start","still","string","string)","string.","subset","support","supported.","syntax","unlik","ur","ure.compile().","ure.compile(regex)","ure.debug","ure.match(regex,","ure.search(regex,","us","value,"],"firmwareapi/micropython/usocket.html":["(after","(bytes,","(conn,","(family,","(if","(ipv4_address,","(rb","(so_*","0","0);","1","1])","5","65535.","8.8.8.8,","80)[0][","=","accept","access","address","address)","address,","address.","alia","allow","alreadi","amount","argument","arguments:","around","associ","automat","avail","backlog","befor","behav","below","below.","binari","bind","block","blocking,","bound","bound.","bsd","buf.","buffer","buffer.","bufsize.","byte","bytes.","calls:","canonname,","case","certain","character.","chosen.","class","close","close()","closed.","collected,","comparison.","completed.","conn","connect","connection,","connection.","connections.","constant","contain","correspond","cpython","cpython'","creat","data","data.","default","defin","depend","destin","differ","domain","dot","e.g.","elaps","enabl","encoding,","end","eof.","equival","errors,","etc.).","exact","exampl","except","expect","explicitly,","express","fail.","false,","famili","family,","file","first","flag","float","flushed).","follow","format","format(s)","function","futur","garbag","given","given,","happens,","host/port","inconsist","instance:","integ","interface.","intern","ip","ipv4","ipv4_address","ipv4_address,","it'","layers:","len(buf)","limit","line","line,","list","listen","lora","lower,","makefile()","makefile().","mani","mark","maximum","method","mode","mode.","mode;","modul","more","name","nbyte","nbytes])","necessari","need","network","new","newlin","non","none","none.","nonneg","notat","note","number","number,","number.","numer","object","object.","object'","occurs.","onc","oper","operations.","option","option.","options:","optname,","origin","otherwise,","pair","paramet","period","point","port","port)","port),","port.","proto,","protocol","protocols:","provid","put","queu","rais","rang","read","read.","reason","receiv","received.","recommend","refus","remot","repres","resolv","return","s","s.bind(1)","s.connect(socket.getaddrinfo('www.micropython.org',","seconds,","see","send","sequenc","server","service.","set","settimeout()","shorthand","show","sigfox","simpli","size","sock.setblocking(false)","sock.setblocking(true)","sock.settimeout(0.0)","sock.settimeout(none)","sockaddr)","socket","socket,","socket.","socket.accept()","socket.af_inet,","socket.af_lora","socket.bind(address)","socket.close()","socket.connect(address)","socket.error,","socket.getaddrinfo().","socket.getaddrinfo(host,","socket.ipproto_tcp","socket.ipproto_tcp)","socket.ipproto_udp,","socket.listen([backlog])","socket.makefile(mode='rb')","socket.read(size)","socket.readall()","socket.readall(),","socket.readinto(buf[,","socket.readline()","socket.recv(bufsize)","socket.recvfrom(bufsize)","socket.send(bytes)","socket.send(bytes).","socket.sendall(bytes)","socket.sendto(bytes,","socket.setblocking(flag)","socket.setsockopt(level,","socket.settimeout(value)","socket.so_bit","socket.so_confirmed,","socket.so_dr","socket.so_oob,","socket.so_reuseaddr","socket.so_rx,","socket.so_tx_repeat,","socket.sock_dgram,","socket.sock_raw","socket.sock_stream,","socket.socket()","socket.socket(socket.af_inet,","socket.sol_lora,","socket.sol_sigfox","socket.sol_socket,","socket.timeout","socket.write(buf)","socket:","sockets,","specifi","specified,","state","statement","store","string","structure:","subsequ","support","supported.","symbol","system","them.","timeout","timeout,","translat","tupl","type","type,","types:","unaccept","until","up","url:","us","usabl","usocket","valu","value)","value:","wb).","well.","write","written.","zero"],"firmwareapi/micropython/select.html":["(obj,","(select","...)","2.","above.","activ","are:","assum","avail","becom","case","class","class.","combin","compat","constant","creat","current","data","default","depend","describ","detect","don't","effici","efficient.","element","empti","end","error","event","event,","eventmask","eventmask)","eventmask])","function","happen","instanc","instead.","list","logic","method","milliseconds.","modifi","modul","more","multipl","obj","obj.","object","objects.","occur","of:","on","operations).","platform","poll","poll.modify(obj,","poll.poll([timeout])","poll.register(obj[,","poll.unregister(obj)","polling.","provid","pyb.uart,","pyb.usb_vcp.","pyboard","read","read/writ","readi","ready.","recommend","regist","return","returned.","select","select.poll()","select.poll*","select.pollerr","select.pollhup","select.pollin","select.pollout","select.pollout.","select.select(rlist,","set","size","specif","specifi","stream","stream/connect","support","termin","timeout","timeout,","timeout])","tuple,","tuples,","unregist","usag","version,","wait","way","wlist,","written","xlist[,","|"],"firmwareapi/micropython/utime.html":["\"new\"","\"old\"","#","(becaus","(for","(includ","(mani","(requir","(rtc).","(see","(which","(year,","+","0","0.","00:00:00","01","0:","1","1,","12","1970","2000.","2014).","23","31","366","500:","500u","59","6","8","=","==",">","above)","above,","absolut","accept","actual","additional,","again","api","application,","arbitrarili","argument","argument,","around","asserted,","assum","backup","baremet","batteri","behav","below","better","between","board","board).","calendar","call","case).","centuri","choice.","clock","compat","compon","consecut","contains:","convert","current","date,","date/tim","date/time.","delay","delays.","depend","develop","directli","done","each","epoch","epoch,","epoch:","esp32","event","exampl","expect","expected.","express","faster.","float","follow","fraction","full","function","function,","functions,","functions.","get","given","gmtime()","gpio","hard","higher","hour","hour,","implement","implicit.","includ","instead.","integ","integer,","intervals,","invers","it'","jan","local","local_tim","localtime()","localtime.","long","machine.rtc()","machine.rtc().datetime(tuple)","maintain","manual","mday","mday,","means:","measur","method","micropython","micropython,","microseconds,","microseconds.","milliseconds,","milliseconds.","minut","minute,","modul","mon","month","month,","need","network","new)","none,","note","number","object.","offset,","opposit","option","os","os/rto","outsid","particular","pattern","per","period","period).","pin","pin.value()","point","poll","port","port/user).","portabl","posit","posix","power","preced","precision,","precision.","protocol","provid","provided,","pycom'","python,","python.","queri","rais","real","refer","reli","requir","reset).","resets,","respons","result","return","rtc","rtc,","rtos),","same","sec","second","second,","seconds,","seconds.","set","set,","set.","setup","short","sleep","sleep_ms()","sleep_us()","standard","start","subtract","such","sun","supported.","system","system/micropython","though","ticks_*()","ticks_cpu().","ticks_diff()","ticks_m","ticks_ms()","ticks_ms(),","ticks_us()","ticks_us(),","ticks_us,","time","time,","time.","time.ticks_diff(start,","time.ticks_us()","time.ticks_us())","time.timezon","timeout:","timeouterror","timezon","timezone,","timezone.","tupl","undefined.","underli","up","uptime,","us","usag","used.","user","usual","utc","utc.","utim","utime.gmtime([secs])","utime.localtime([secs])","utime.mktime()","utime.sleep(seconds)","utime.sleep_ms(ms)","utime.sleep_us(us)","utime.ticks_cpu()","utime.ticks_diff(old,","utime.ticks_ms()","utime.ticks_us()","utime.time()","utime.timezone([secs])","valu","value.","wait","want","way","weekday","weekday,","without","work","wrap","write","year","yearday","yearday)"],"firmwareapi/micropython/uhashlib.html":["1","224","256","384","512","achiev","activ","algorithms.","binari","byte","called,","class","constructor","creat","data","effect.","fed","feed","hardware,","hash","hash,","hash.","hash.digest()","hash.hexdigest()","hash.update(data)","hasher","implement","implemented.","it.","limit","longer.","md5","method","modul","more","object","object.","on","oper","option","pass","return","sha","similar","support","supported.","through","time.","ubinascii.hexlify(hash.digest())","uhashlib","uhashlib.md5([data])","uhashlib.sha1([data])","uhashlib.sha224([data])","uhashlib.sha256([data])","uhashlib.sha384([data])","uhashlib.sha512([data])","us"],"firmwareapi/micropython/ussl.html":["\"secur","(often","/flash/cert/.","1])","443)[0][","8441)[0][","=","access","authent","blynk","both","ca.pem","ca_certs='/flash/cert/ca.pem')","ca_certs=none)","cert_req","cert_reqs=cert_none,","cert_reqs=ssl.cert_required,","certfile=none,","certif","certificates,","client","connect","connection,","constant","context.","do:","encrypt","end.","exampl","example:","except","facil","file","folder","ftp","import","inherit","instanc","instance,","keyfile=none,","known","layer","layer\")","locat","method","modul","module.","names.","network","order","ourselv","path","peer","place","provid","put","return","s","secur","see","server","server,","server_side=false,","side","side.","sock","socket","socket.socket()","socket.socket,","sockets,","specif","ss","ss.connect(socket.getaddrinfo('cloud.blynk.cc',","ss.connect(socket.getaddrinfo('www.google.com',","ssl","ssl.cert_none,","ssl.cert_optional,","ssl.cert_required:","ssl.sslerror","ssl.sslsocket,","ssl.wrap_socket(s)","ssl.wrap_socket(s,","ssl.wrap_socket(sock,","standard","store","subtyp","such","support","take","transport","underli","us","usocket","ussl","valid","valu","wrap"],"firmwareapi/micropython/ucrypto.html":["\"...","\"these","32","accord","advanc","ae","algorithms.","base","basi","bit","bits.","bt","business.","byte","class","crypto.getrandbits(bits)","cryptograph","cryptographi","decreas","depend","disabled,","do","document","encrypt","esp32","fi","fi/bt","fill","gener","generator.","give","hardwar","import","information.","it'","loos","manual,","method","modul","multipl","nativ","nearest","nois","number","numbers.\"","object","obtain","operations\".","out","paramet","pleas","provid","pseudo","pycrypto.","quickli","random","refer","result","return","rf","round","secur","security.","standard","subject","such","support","system.","technic","thing","trivial","true","ucrypto","upward","us","way","wi","wrong","yourself"],"firmwareapi/micropython/ustruct.html":["!.","(the",",","...","...)","2","@,","accord","b,","buffer","buffer,","buffer.","byte","codes:","count","d","data","data)","data,","depend","encod","end","f,","float","fmt","fmt.","format","given","h,","i,","information.","l,","latter","method","more","need","neg","number","object","offset","offset,","offset.","offset=0)","order","p,","pack","point","prefixes:","python","q,","return","s,","see","size/byt","start","store","string","struct","support","support).","tupl","unpack","ustruct","ustruct.calcsize(fmt)","ustruct.pack(fmt,","ustruct.pack_into(fmt,","ustruct.unpack(fmt,","ustruct.unpack_from(fmt,","v1,","v2,","valu","values."],"firmwareapi/micropython/_thread.html":["%","%d'","(4kib).","(also","(but","(i","(in","(onli","(use","(which","+","0","1)","1,","4096","4kib","=","_thread","_thread.allocate_lock()","_thread.exit()","_thread.get_ident()","_thread.locktyp","_thread.stack_size([size])","_thread.start_new_thread(function,","_thread.start_new_thread(th_func,","a_lock","a_lock:","above.","acquir","action","addit","anoth","arg","args[,","argument","argument,","arguments.","befor","below.","between","binari","bytes)","call","caught,","caus","class","configur","continu","control","cooki","creat","created.","current","data","data.","def","default)","depend","describ","dictionari","direct","e.g.","e.g.:","earlier,","error","exampl","except","exception,","exception.","execut","executes\")","existence).","exit","exits.","fals","float","follow","function","global","guarante","i))","id)","id):","identifi","identifier.","immedi","import","index","initi","integ","integer.","intend","interpret","itself.","keyword","kwarg","kwargs])","level","light","list","lock","lock.","lock.acquire(waitflag=1,","lock.locked()","lock.release()","lock:","low","magic","maximum","meaning;","method","methods,","methods:","minimum","modul","multipl","mutex","necessari","necessarili","neg","new","nonzero","nonzero,","not.","object","object.","objects.","occur","on","option","platform","point","posit","positive,","present","present,","primit","print","print(\"a_lock","print('run","process","provid","provided.","quick","rais","raised.","range(2):","reason","recycl","releas","return","returning.","returns,","run).","runtimeerror","same","second","semaphores)","share","silent","silently.","simpl","size","space","space.","specif","specifi","stack","start","statement,","statu","subsequ","successfully,","suffici","support","synchronis","synchronisation,","systemexit","tasks)","termin","th_func(delay,","that'","thread","thread,","thread.","threads,","threads.","time","time.sleep(delay)","timeout","timeout=","trace","true","true:","tuple).","type","unbound","uncondition","unconditionally,","unhandl","unlocked.","until","us","usag","valu","value:","via","wait","wait.","waitflag","waiting,","weight","without","work","zero,","zero.","—"],"firmwareapi/micropython/builtin.html":["abs()","all()","any()","avail","bin()","bool","builtin","byte","bytearray","callable()","chr()","class","compile()","complex","describ","dict","dir()","divmod()","enumerate()","eval()","exec()","filter()","float","frozenset","function","getattr()","globals()","hasattr()","hash()","here.","hex()","id()","input()","int","isinstance()","issubclass()","iter()","len()","list","locals()","map()","max()","memoryview","method()","min()","module.","next()","object","oct()","open()","ord()","pow()","print()","property()","range()","repr()","reversed()","round()","set","setattr()","sorted()","staticmethod()","str","sum()","super()","tupl","type()","via","zip()"],"firmwareapi/notes.html":[".callback()","16","2","alarm","alloc","allow","along","appropri","argument.","associ","attend","bear","both","callback","callback,","called.","class","classes.","creat","current","currently,","default","detail","differently.","done","enabl","esp32","even","event","event.","example,","examples,","given","handl","handler","handler.","happens,","ideal","insid","interrupt","interrupts.","interrupts;","keep","limit","memori","messag","method","micropython","mind","minimum","more","network","new","note","notifi","object","order","packets.","pin","pleas","port","possibl","post","process","provid","pycom'","queue","queue,","rais","receiv","regist","requir","respect","restrict","sections.","send","separ","sequenti","short","sockets.","such","support","system","thread","thu","time.","up","us","usag","user","variables,","visit","whatev","within"],"datasheets/introduction.html":["board","contain","develop","each","exampl","examples:","expans","follow","inform","introduct","modul","notes.","oem","page","pinouts,","product,","relat","relev","sheets,","shield","spec"],"datasheets/development/":["2.0","3.0,","4,","contain","datasheet","develop","devices.","fipy.","gpy,","includ","lopi","lopy,","modul","pycom","section","sipy,","wipi"],"datasheets/development/wipy2.html":["\"deep","(clk,","(sda,","(tx1/rx1),","**","****","10ma.","10ua","10ua.","2","2.0","2ma","3.3v","3.5v","4","5.5v.","7ua","access","allow","alongsid","alway","around","assign","attach","avail","between","ble","board","boot","caus","chang","chip","click","configured.","connect","consum","consumpt","control","coupl","creat","cs","current","current.","cut","damaged.","datasheet","dc","deep","default","default,","depend","design","devic","device.","digit","discontinued,","documentation.","doesn't","domain,","down","draw","due","dure","eco","enabl","enter","exampl","feed","file.","flash","float","follow","found","get","goe","hand","here","high","i2c","interest","interrupt.","issu","keep","lowest","miso)","mode","mode,","modul","more","mosi,","note","number,","only,","otherwis","out","output","password","pdf","perform","pin","pinout","pleas","point","possibl","power","provid","put","pwm","quiescent","random","rang","re","regul","rippl","rtc","scl)","section","see","shield","shield\"","sleep","sleep.","software.","sourc","specif","spi","ssid","started:","stay","store:","suppli","switch","therefor","timer","tutori","uart1","unfortunately,","upon","us","usabl","use.","via","vin","voltag","wake","wifi","wipi","wipy2","wipy2,","wipy2:","wipy3","wlan","work","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/wipy3.html":["(clk,","(p12)","(sda,","(tx1/rx1),","**","****","19.7µa","2.0","3.0","3.3v","3.5v","4","4mb","5.5v.","512kb","8mb","access","antenna","application.","assign","avail","avoid","between","ble","board","boot","buy","chang","click","connect","creat","current","damaged.","datasheet","deep","default","default,","differ","digit","disabl","documentation.","draw","exampl","extern","feed","file.","fixed,","flash","follow","found","get","gpio16","gpio21","hand","here","i2c","interest","miso)","modul","mosi,","move","note","now","number,","only,","otherwis","output","p12","p12,","password","pdf","pin","pinout","pleas","point","power","ram","random","rang","reason","regul","rf","scl)","section","select","sleep","software.","specif","spi","ssid","started:","store:","suppli","switch","tutori","uart1","unless","upgrad","upon","us","vin","voltag","wifi","wipi","wipy3","wipy3,","wipy3:","wlan","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/lopy.html":["\"deep","(clk,","(sda,","(tx1/rx1),","**","****","10ma.","10ua","10ua.","2ma","3.3v","3.5v","4","5.5v.","7ua","access","allow","alongsid","alway","around","assign","attach","avail","between","ble","board","boot","buy","caus","chang","chip","click","configured.","connect","consum","consumpt","control","coupl","creat","cs","current","current.","cut","damaged.","datasheet","dc","deep","default","default,","depend","design","devic","device.","digit","documentation.","doesn't","domain,","down","draw","due","dure","eco","enabl","enter","exampl","feed","file","file.","flash","float","follow","found","gateway","get","goe","hand","here","high","i2c","interest","interrupt.","issu","keep","lopi","lopy,","lopy:","lorawan","lowest","miso)","mode","mode,","modul","more","mosi,","nano","node","note","number,","only,","otherwis","out","output","password","pdf","perform","pin","pinout","pleas","point","possibl","power","provid","put","pwm","quiescent","random","rang","re","regul","rippl","rtc","scl)","section","shield","shield\"","sleep","sleep.","software.","sourc","specif","spi","ssid","started:","stay","store:","suppli","switch","therefor","timer","tutori","uart1","unfortunately,","upon","us","usabl","use.","via","vin","voltag","wake","wifi","wlan","work","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/lopy4.html":["(clk,","(sda,","(tx1/rx1),","**","****","3.3v","3.5v","4","5.5v.","access","antenna","application.","assign","avail","avoid","between","ble","board","boot","buy","chang","click","connect","creat","damaged.","datasheet","default","default,","digit","disabl","documentation.","exampl","extern","feed","file","file.","follow","found","gateway","get","hand","here","i2c","interest","lopi","lopy4","lopy4,","lopy4:","lorawan","miso)","modul","mosi,","nano","node","note","number,","only,","otherwis","output","p12","p12,","password","pdf","pin","pinout","pleas","point","power","random","rang","reason","regul","rf","scl)","section","select","sigfox","software.","specif","spi","ssid","started:","store:","suppli","switch","tutori","uart1","unless","upon","us","vin","voltag","wifi","wlan","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/sipy.html":["\"deep","(clk,","(sda,","(tx1/rx1),","**","****","10ma.","10ua","10ua.","2ma","3.3v","3.5v","4","5.5v.","7ua","access","allow","alongsid","alway","around","assign","attach","avail","between","ble","board","boot","buy","caus","chang","chip","click","configured.","connect","consum","consumpt","control","coupl","creat","cs","current","current.","cut","damaged.","datasheet","dc","deep","default","default,","depend","design","devic","device.","digit","documentation.","doesn't","domain,","down","draw","due","dure","eco","enabl","enter","exampl","feed","file","file.","flash","float","follow","found","get","goe","hand","here","high","i2c","interest","interrupt.","issu","keep","lowest","miso)","mode","mode,","modul","more","mosi,","note","number,","only,","otherwis","out","output","password","pdf","perform","pin","pinout","pleas","point","possibl","power","provid","put","pwm","quiescent","random","rang","re","regul","rippl","rtc","scl)","section","shield","shield\"","sigfox","sipi","sipy,","sipy:","sleep","sleep.","software.","sourc","specif","spi","ssid","started:","stay","store:","suppli","switch","therefor","timer","tutori","uart1","unfortunately,","upon","us","usabl","use.","via","vin","voltag","wake","wifi","wlan","work","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/gpy.html":["(clk,","(sda,","(tx1/rx1),","**","****","3.3v","3.5v","4","5.5v.","access","antenna","application.","assign","avail","avoid","between","ble","board","boot","buy","cat","chang","click","command","connect","creat","damaged.","datasheet","default","default,","digit","disabl","documentation.","draw","exampl","extern","feed","file","file.","follow","found","get","gpi","gpy,","gpy:","hand","here","i2c","interest","iot","lte","m","m1","miso)","modem","modul","monarch","mosi,","nb","note","number,","only,","otherwis","output","p12","p12,","password","pdf","pin","pinout","pleas","point","power","random","rang","reason","regul","rf","scl)","section","select","sequan","software.","specif","spi","ssid","started:","store:","suppli","switch","tutori","uart1","unless","upon","us","vin","voltag","wifi","wlan","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/fipy.html":["(clk,","(sda,","(tx1/rx1),","**","****","3.3v","3.5v","4","5.5v.","access","antenna","application.","assign","avail","avoid","between","ble","board","boot","buy","cat","chang","click","command","connect","creat","damaged.","datasheet","default","default,","digit","disabl","documentation.","draw","exampl","extern","feed","file","file.","fipi","fipy,","fipy:","follow","found","gateway","get","hand","here","i2c","interest","iot","lorawan","lte","m","m1","miso)","modem","modul","monarch","mosi,","nano","nb","node","note","number,","only,","otherwis","output","p12","p12,","password","pdf","pin","pinout","pleas","point","power","random","rang","reason","regul","rf","scl)","section","select","sequan","sigfox","software.","specif","spi","ssid","started:","store:","suppli","switch","tutori","uart1","unless","upon","us","vin","voltag","wifi","wlan","www.pycom.io.","xxxx","xxxx,"],"datasheets/oem/":["contain","datasheet","devices.","g01.","includ","l01,","l04,","modul","oem","pycom","section","w01,"],"datasheets/oem/w01.html":["(clk,","(sda,","(tx1/rx1),","assign","avail","ble","chang","connect","datasheet","default","documentation.","draw","exampl","file","file.","follow","found","i2c","interest","miso)","modul","mosi,","note","pdf","pin","pinout","pleas","scl)","section","software.","specif","spi","tutori","uart1","w01","w01:","wifi"],"datasheets/oem/l01.html":["(clk,","(sda,","(tx1/rx1),","assign","avail","ble","chang","connect","datasheet","default","documentation.","draw","exampl","file","file.","follow","found","gateway","i2c","interest","l01","l01:","lorawan","miso)","modul","mosi,","nano","node","note","pdf","pin","pinout","pleas","scl)","section","software.","specif","spi","tutori","uart1","wifi"],"datasheets/oem/l04.html":["(clk,","(sda,","(tx1/rx1),","assign","avail","ble","chang","connect","datasheet","default","documentation.","draw","exampl","file","file.","follow","found","gateway","i2c","interest","l04","l04:","lorawan","miso)","modul","mosi,","nano","node","note","pdf","pin","pinout","pleas","scl)","section","sigfox","software.","specif","spi","tutori","uart1","wifi"],"datasheets/oem/g01.html":["(clk,","(sda,","(tx1/rx1),","assign","avail","ble","cat","chang","command","connect","datasheet","default","documentation.","draw","exampl","file","file.","follow","found","g01","g01:","i2c","interest","iot","lte","m1","miso)","modem","modul","monarch","mosi,","nb","note","pdf","pin","pinout","pleas","scl)","section","sequan","software.","specif","spi","tutori","uart1","wifi"],"datasheets/oem/l01_reference.html":["2.4ghz","3.5","5.5","abil","accommod","altium","antenna","avail","baseboard","bluetooth,","board","both","button","connection.","connector","connector.","current","dc","deep","design","doubl","draw","dure","extern","featur","file","file.","g01","g01,","gerber","input","l01","l01'","l04","layout","layout/gitbook/assets/l01","layout.pdf)","led","lora","low","make","mode","modul","modules.","oem","output.","pcb","pdf","pleas","possibl","project","refer","regul","requir","reset","rgb","schemat","sim","singl","sleep","slot","suit","suitabl","switch","u.fl","univers","us","via","w01","well","wifi","ws2812b","zip"],"datasheets/oem/universal_reference.html":["(l01,","2.4ghz","3","3.5","5.5","abil","accommod","altium","antenna","avail","baseboard","bluetooth,","board","button","connector","connector.","contain","current","dc","deep","design","draw","dure","extern","featur","file","file.","g01","g01)","g01,","gerber","input","l01","l01,","l04","l04,","layout","led","low","make","mode","modul","modules,","modules.","necessari","oem","output","pcb","pdf","possibl","project","refer","regul","requir","reset","rgb","schemat","sim","singl","sleep","slot.","suit","suitabl","suitable.","switch","u.fl","univers","via","w01,","wifi","ws2812b","zip"],"datasheets/boards/":["board","board,","contain","datasheet","deep","expans","includ","pycom","pysens","pytrack,","section","shield","shield.","shields.","sleep"],"datasheets/boards/expansion3.html":["\"safe","(connect","(if","100ma.","10k","3","3.0","3.3v","3v3).","450ma.","ad","allow","altium","application,","automat","avail","batteri","battery,","be","between","board","boards.","boot","boot\"","boot.","bootload","break","button","card","cell","charg","charger","charger.","chg","chip","connect","connected).","connector","connector,","connector.","current","custom","datasheet","dfu","differ","difficult","easier.","enter","expans","featur","file","file.","firmwar","fix.","ftdi","gentl","gerber","held","high","ion/li","jumper","li","lower","micro","mode,","mode.","modul","module,","oem","p12","p8/g15","pdf","perform","pic","pinout","plugging/unplug","po","power","present","press","program","project","pull","put","pycom","pysense/pytrack/pyscan","rel","remov","replac","reset","safe","sd","singl","solder","stay","strong,","tool","troubleshoot","up.","updat","us","usb","util","v2.0","v3.0","valu","veri","via","want","well,","whilst"],"datasheets/boards/pytrack.html":["(if","avail","batteri","be","board","cell","charg","charger","charger.","connected).","connector,","datasheet","featur","file","file.","ion/li","li","micro","pdf","pinout","po","power","pytrack","singl","usb","via"],"datasheets/boards/pysense.html":["(if","avail","batteri","be","board","cell","charg","charger","charger.","connected).","connector,","datasheet","featur","file","file.","ion/li","li","micro","pdf","pinout","po","power","pysens","singl","usb","via"],"datasheets/boards/pyscan.html":["(if","01","151","329al","7","acceleromet","accelerometer:","ad","ambient","avail","batteri","be","being,","board","cell","charg","charger","charger.","compon","components:","connected).","connector,","current","datasheet","driver","due","featur","file","file.","fix","ftp","here","here.","ion/li","li","librari","light","limit","lis2hh12","lite","locat","ltr","mfrc630.mpi","mfrc63002hn,","micro","nxp","oper","pdf","pinout","po","power","pymakr","pyscan","reader","reader:","recommend","required.","rest","rfid/nfc","sensor:","shortly.","singl","soon.","st","system","there'","time","upload","us","usb","via","window"],"datasheets/boards/expansion2.html":["(if","100ma.","2","2.0","450ma.","application,","avail","batteri","be","board","break","cell","charg","charger","charger.","chg","connected).","connector","connector,","connector.","current","datasheet","difficult","expans","featur","file","file.","fix.","gentl","high","ion/li","jumper","li","lower","micro","pdf","pinout","plugging/unplug","po","power","present","rel","remov","singl","solder","strong,","usb","valu","veri","via","whilst"],"datasheets/boards/deepsleep/":["2.0,","align","avail","board","connect","correctli","deep","devic","device.","expans","file","file.","led","lopi","onc","onto","pdf","pinout","pycom","schemat","seat","shield","shield,","sipi","sleep","triangl","white","wipi"],"datasheets/boards/deepsleep/api.html":["#","'p18'])","'p18'].","(e.g.","(i.e.","(see","/lib","3.3v,","60","=","==","['p17',","accelerometer,","ad","allow","api","associ","available,","batteri","be","below","board","board'","button).","cell)","chapter","class","constructor","contribut","control","creat","critic","deep","deepsleep","deepsleep()","deepsleep.disable_pullups(pins)","deepsleep.disable_wake_on_fall(pins)","deepsleep.disable_wake_on_raise(pins)","deepsleep.enable_auto_poweroff()","deepsleep.enable_pullups(pins)","deepsleep.enable_wake_on_fall(pins)","deepsleep.enable_wake_on_raise(pins)","deepsleep.get_wake_status()","deepsleep.go_to_sleep(seconds)","deepsleep.hw_reset()","deepsleep.pin_wake:","deepsleep.power_on_wake:","deepsleep.set_min_voltage_limit(value)","deepsleep.timer_wake:","describ","devic","device.","dict","disabl","disabled.","ds","ds.enable_pullups('p17')","ds.enable_pullups(['p17',","ds.enable_wake_on_fall('p17')","ds.enable_wake_on_fall(['p17',","ds.get_wake_status()","ds.go_to_sleep(60)","dure","elif","else:","enable_auto_poweroff","enabled.","exampl","example,","example;","extern","fall","featur","features.","feel","free","function","functionality.","github","go","hardwar","i.e.","import","includ","intend","interrupt","librari","libraries.","library,","lipo","list,","method","minimum","more","note","object,","occurs,","p10,","p17,","p18.","pass","period","pic","pin","pins/min","pleas","power","previou","print(\"pin","print(\"pow","print(\"tim","print(wake_s)","protect","pull","pycom","quick","reason","relat","repository.","request","requir","reset","reset\")","return","rise","second","send","set.","set_pullups).","setup","shield","shield.","sleep","sleep.","sourc","specifi","state","statu","target","timer","trigger","turn","under","until","up","up\")","upload","us","user","valu","value.","via","voltag","voltage.","wake","wake,","wake_","wake_s['wake']","wakeup","weekli"],"datasheets/notes.html":["(e.g.","(silver","2","3.3v","3.4v","5.5v.","5v","adapt","against","area","bag","batteri","be","befor","best","between","board","board,","board.","cabl","came","care","carri","caus","check","climates),","cold","compon","connect","connector","damag","destroy","devic","device.","devices.","discharges.","dri","electr","esd","expans","expos","extern","extra","femal","gnd.","gpio","ground","higher","input","insid","irrepar","jst","lead","lot","male","modul","note","order","packaging),","phr","pin","pleas","plug","polar","posit","power","protect","pycom","requir","shock","sourc","source.","static","store","suppli","sure","swapping.","take","them.","tolerant,","us","variant.","via","vin","vin,","vin:","voltag","way"],"pybytes/introduction.html":["accord","accur","air:","alarms.","allow","api","applic","approach.","asset","batteri","boards.","check","command","connect","control","customis","customisable,","dashboard","dashboard;","data","defin","design","devic","device'","devices.","distribut","downgrad","ecosystem","email","empow","entir","environ","exclus","execut","extern","feature;","firmwar","fleet;","freeli","full","gather","geoloc","geolocation.","get","googl","grant","indic","inform","intellig","interest","introduct","iot","keep","key","let'","level,","map","measur","modul","more:","notif","notifications:","nutshell,","offer","optimis","over","perform","position:","pre","pybyt","pybytes?","pycom","receiv","scalabl","sensor","sensors.","seri","services​","set","shell.","sms.","start","started!","statu","status,","stream","termin","terminal:","time","track","up","updat","update.","upgrad","us","version","via","view","visualis","visualisation:","you?","​integr"],"pybytes/getstarted.html":["1:","account.","account:","address","address.","board","click","complet","confirm","connect","creat","email","enter","explor","follow","full","get","go","invent!","it'","link","link.","login.","messag","name,","now","page","password","pybyt","pybytes.","pycom","registr","sent","start","step","time","verif"],"pybytes/connect/":["\"add","(e.g.,","(recommended)","(ssid","/frozen","1.16.x","1:","2:","ad","add","between","built","choos","click","come","connect","credenti","devic","device\"","device.","device;","end","enter","etc.);","explain","firmwar","flash","folder.","give","go","librari","lopy,","manually.","mean","name","network","onward","option","option;","other);","page:","password)","pybyt","pybytes,","pybytes:","pycom","pyscan","pysense,","pytrack,","quickli","section,","select","shield","sipy,","step","two","uniqu","updat","wipy,","wizard","wizard,"],"pybytes/connect/quick.html":["\"add","\"eras","\"forc","(make","1:","2:","add","case","click","computer);","computer.","connect","copi","dashboard!","dashboard.","data","devic","device\"","device'","display","download","explain","extend","file","firmwar","firmware.","flash","here","information.","instal","it'","last","librari","manually.","mark","more","next","now","oper","option","past","port","process:","pybyt","pybytes:","pybytes;","quick","quickli","registration\";","section,","select","serial","set","start","step","step:","sure","system\"","system;","time","token","token.","up","updat","updater.","updater;","us","want"],"pybytes/connect/flash.html":["\"add","\"address\":","\"flash\"","\"micro\",","\"password\":","\"paste_your_serial_port_here\",","\"pybyt","\"python\",","\"sync_folder\":","\"username\":","/flash","/frozen","1.16.x","1:","2.",">","add","atom.","boot","build","button","cable.","case","chang","checkout","click","code","come","comput","connect","credentials.","dashboard!","dashboard.","data","devic","device\"","device'","device,","devicetoken","display","download","e.g.","explain","extract","file","file.","file:","fill","firmwar","flash","flash/pybytes_config.json","folder","folder.","follow","haven't","here","here.","inform","information.","instal","instructions.","it'","last","librari","library\"","library;","manual","manually.","mean","mode.","more","navig","need","next","now","onward","open","over","page","page:","password","past","plugin","plugin,","port","port:","pre","preced","process:","put","pybyt","pybytes.","pybytes:","pybytes;","pycom","pymakr","pymakr.","pymakr.conf","quickli","restart","safe","section,","serial","set","step","step:","tab;","take","time","up","upload","usb","wifi","without","written","{","}"],"pybytes/connect/sigfox/":["[r]","[w].","access","account","account.","add","api","arbitrari","backend,","befor","chose","click","clipboard.","contract","contract.","copi","creat","credenti","custom","devic","devkit","follow","form","form.","go","group","instructions.","link","log","login","manag","more","name,","need","new","ok.","onc","password","past","profil","pybyt","pybytes.","pycom","read","select","set","setup","sigfox","start","type","us","→"],"pybytes/connect/sigfox/devkit.html":["(it","(lopy4,","(on","(which","activ","add","api","api).","associ","automat","backend","backend.","button","callback","check","click","clipboard.","come","component.","comput","configur","connect","connectivity.","contain","contract","contract,","contract.","copi","creat","credenti","custom","default","describ","detail","dev","devic","device),","devices,","devkit","disengag","fipy)","firmwar","first","found","free","go","great","green","group","here.","hold","http","issu","kit","light","lights.","mani","mean","need","note","now","number","on","page","past","post","procedure.","prototyping.","provid","pybyt","pybytes).","pybytes.","pycom","regist","repeat","same","save","second","see","select","sequenc","set","sigfox","sipy,","statu","step","therefor","to:","token","troubleshoot","two","type","type.","types.","updat","updater.","us","want","year","→"],"pybytes/connect/sigfox/custom.html":["(in","(lopy4,","(pybyt","ad","add","api","applic","associ","automat","automatically).","backend","backend.","build","buy","clipboard.","complet","comput","connect","contract","contract.","copi","creat","custom","describ","detail","devic","disengag","fipy)","firmwar","flash","go","here.","itself","newli","number","past","pybyt","pybytes.","pycom","recommend","regist","same","select","sequenc","set","sidebar)","sigfox","sipy,","start","step","talk","to:","token","troubleshoot","type","updat","updater.","us","→"],"pybytes/dashboard.html":["#","(e.g.","(in","(main.py)","1);","10","1:","2:","3:","4:","=","_thread","access","action.","ad","add","added!","adjust","after,","allow","alreadi","also,","applic","argument","arguments:","assum","attribut","bar","be","bottom","button","button.","call","call,","card.","case","chang","chart","chart).","check","checkbox","click","code","code,","commun","connect","corner","creat","create.","created.","cursor","dashboard","dashboard'","dashboard.","data","data.","data;","datatyp","def","defin","define.","denot","devic","device'","device.","device;","display","display.","done","done!","drag","drop","each","edit","enter","exampl","example.","explain","file","finally,","first","float","float32).","follow","function","go","grid","grid.","haven't,","here.","icon","identifi","import","inc(index,","increment","index","inform","infrequ","insert","insid","label","learn","library,","line","main.pi","main.py;","mark","match","mode","modified;","more","name","name,","necessari","new","next","now","now,","number","number,","number;","open","organis","organise.","over","page","paramet","part","particular","persist","persistent,","pin","pin,","point","posit","proce","pybyt","pybytes.","pybytes.send_virtual_pin_valu","pybytes.send_virtual_pin_value(persistent,","pymakr;","rad","receiv","reposit","repres","resiz","right","run","save","save.","scan","second","section,","select","send","sensors_data","set","settings.","signal","sinwav","sleep","step","successfulli","tab","tab.","that,","there!","therefor","thread","three","time","triangl","type","unit","unit).","unit.","up","upload","us","valu","value))","value.","variabl","vector","vector):","virtual","visualis","we'r","widget","widget'","widget.","widgets.","you'v"],"pybytes/integrations/":["applic","cloud","connect","custom","devic","easili","extern","following:","integr","interact","iot","iot:","let","manag","offer","platform","pybyt","secur","servic","services,","way","​aw"],"pybytes/integrations/amazon-iot.html":["(just","allow","allowed),","alphanumer","alway","amazon","attribut","aw","aws,","aws.","binari","bind","broker,","choos","click","client.","consid","consider","consol","correspond","creat","credentials.","custom","dash","data","database.","delet","details.","devic","device'","directli","done,","download","endpoint","everything'","expected,","explor","fill","final","following:","form","futur","future,","generated,","go","group","groups.","insid","integr","integration.","interfac","interface,","iot","it'","key","letter,","local","log","login","messag","mqtt","name","new","notic","on","onc","option","order","otherwis","pass","payload","pleas","possibl","privat","pybyt","pybytes.","ready,","receiv","region","republish","rule.","same","save","secur","see","send","servic","set","sidebar,","specifi","step,","stop","storag","store","summari","test","thing","thing.","things'","topbar.","topic","underscor","up","us","use.","user","want","warning:","way","web","well,","whenev","work","working.","you'll","you'r"],"docnotes/introduction.html":["adher","aim","allow","clariti","confus","design","document","documentation.","eas","featur","however,","introduct","language.","micropython","new","provid","pycom","python","section","specif","straightforward","style","those","typic","understanding.","unusu","us"],"docnotes/syntax.html":["#","'p11'))","(0)","(a","(in","(pin='p12')","(tuple)","(upon","*",",","0))","0,","1,","100000.","13,","4,","5,","=","accept","adc","adc()","adc.channel(*","adc.channel(pin='p16')","allow","alway","analog","anoth","apin","appar","appli","argument","arguments.","assum","astrik","attn=adc.attn_0db)","awar","baudrat","baudrate=100000,","be","befor","below","below,","below.","below:","between","call","called:","case,","certain","channel","class","class,","class.","classes,","color,","constant","constants.","construct","constructor","contain","correct","creat","datetime.","default","denot","describ","descript","design","detail","differ","doc","docs),","document","documentation.","error","exampl","example,","examples/docs)","execut","familiaris","first","follow","format","frequency=5000)","function","gener","i.e.","i2c.init()","i2c.init(i2c.master,","i2c.init(mode,","i2c.master()","id","id.","import","incorrect","input","input.","instead","intent","it,","keyword","keyword,","keyword.","lack","librari","library.","library'","list","machin","method","methods.","micropython","mode","name","name,","name.","notabl","note","noth","object","object).","of.","order","outlin","p16","pass","passed.","pin","pin,","pin='p12')","pin='p16'","pins=('p12',","pins=(sda,","pleas","point","popular","provided.","pwm","pwm(0,","pwm.channel()","pwm.channel(0,","pwm_c","pycom","pycom.rgbled(0xff0000)","pycom.rgbled(color)","pycom.rgbled(color=0xff0000)","python","refer","referenc","regard","reli","requir","return","review","rgbled.","rtc","rtc()","rtc.init((2014,","rtc.init()","rtc.init(datetime)","rtc.init(datetime=(2014,","scl))","section","see","seen","show","specif","specifi","sphinx","standard","state","symbol","syntax","take","thu","to.","tool.","two","typeerror:","unless","upon","us","user","utilis","valid","valu","value.","well","within","without","yourself"],"docnotes/replscript.html":["\"b'3132333435'\"","#","'2'","+","1","1)","=","anyth","arithmet","assign","automat","awar","basic","be","behaviour.","below","both","call","called,","certain","classes/funct","code","consol","console.","demonstr","display","doc","document","exampl","example:","execut","expect","function","given","here...","immedi","import","later","mani","mean","method","micropython","necessarili","need","order","out","output","print","print()","print(1","print(value)","produc","repl","repl.","return","run","save","script","script.","snippet","someth","statement","them.","ubinascii","ubinascii.hexlify(b'12345')","under","us","user","valu","values,","variabl","vs","wish","wrap"],"docnotes/mesh-networks.html":["click","current","development.","document","documentation.","here","informational.","keep","mesh","mind","network","pleas","still","under"],"advance/downgrade.html":["$","(see","...",".tar",".tar(.gz)",".tar.gz","/path/to/firmware/archive.tar.gz","1.0","1.12.0.b0","1.16.0.b1","2.0,","achiev","address","agnost","appear.","archiv","avail","bar","befor","beginning.","behav","below.","between","block","board","board.","button","cli","click","command","commands:","config","connect","devic","device.","downgrad","download","expans","file","fipi","firmwar","flash","follow","frequenc","function","fwtool","g23","gnd","gpi","gui","here).","here:","instead","jumper","latest","latest.","line","local","locat","lopi","lopy4","lora","method","modul","need","now","obtain","onward,","option,","p","point","port","press","previou","prior","procedur","programat","provid","pycom","region","regular","requir","reset","run","screen:","see","set","sipi","specific.","start","t","this.","tick","tool","tool,","two","updat","upgrad","upload","us","usual","v","version","version.","via","wipi","wish"],"advance/cli.html":["$","$pycom","&","(all,","(and","(base64)","(default)","(default:","(lpmac,","(requir","(x86)\\pycom\\pycom","(you","**environ","...","./pyupgrad",".bin)",".cb",".nv",".ota",".tar(.gz)","/","/dev/cu.bluetooth","/dev/cu.usbmodempy343431","/usr/local/bin.","1.14.3).","1.17.5.b6","14.04","2.0","230400.","2]","3","32","3rd","64","921600.",":","[","[command","[command]","[global","[n/a]","[pytrack]","[usb","[wob]","[wob]]","_stub_","`","abov","access","ad","addit","address","address,","address]","again","allow","alreadi","ambiguity.","area","area.","arguments:","as923","au915]","automat","avail","avoid","b","b,","b]","backup","backup.","backup.cb","backup.nv","backup.ota","base","baudrat","befor","below.","between","binari","bit","block","block,","block:","board","boot","bootloader,","button","c","c,","c:\\program","c]","call","caus","cb","certain","chip_id","circumstances.","cli","cli.","cli.ex","click","code","com","com6","combin","command","command,","command.","commands,","config","config)","configur","configuration.","connect","connection.","contain","content","contents,","contents/resources,","contents]","continu","continuation`","copi","courtesi","crash","d","d,","d]","data","debug","debug`","debuggin","default","detail","details.","devic","device.","doing.","done","each","entir","environ","eras","erase_al","erase_f","erase_region","esp32","espbaud**","espbaud.","espport","espport**","espressif","espressif'","esptool","esptool.","etc.","etc.).","eu868","example:","exit","expans","extra","extract","extrapref","extraprefs]","f","factory,","file","file,","file]","files\\pycom\\pycom","find","firmwar","firmware.","first","flash","flash!","flash,","folder","forc","found","from/to","fs,","fs1,","ftdi","ftdi]","ftdi`","function","fwtool","fwtool.","g23","gener","get/set","github.","global","gnd","h","h,","h]","hang","hardwar","hash","have","help","help`","here","here.","here:","higher","https://docs.pycom.io/chapter/advance/cli.html","id","id,","ignor","imag","import","incom","instal","intend","jumper","know","leav","left","line","linux","list","local","locat","location=20","lora","lora_region","lpwan","lt","mac","maco","macos,","macos:","make","maximum","memori","memory.","messag","method","mode","mode.","modif","modul","module.","more","mqtt","mqtt]","mqttserviceaddress","multipl","name","navig","necessary.","need","network","newer)","noexit","noexit`","non","note","note:","nv","nvs,","nvs:","nwpref","nwprefs]","once,","onto","oper","option","option,","option.","order","ota","ota_0,","otadata,","output","output,","overwritten","p","pac","packag","package,","paramet","parameters.","parameters]","parti","partit","partition,","partition]","partitions,","perform","pic","pic]","pic`","pleas","port","port,","port]","port`","ports.","posit","prefer","press","prevent","previou","previous","products.","program","provid","provided,","pwd","pwd]","pybyt","pybytes_config.json","pycom","pycom.","pysense/pytrack/expans","q","q,","q]","quiet","quiet`","r","r,","r]","read","read/writ","reduc","region","region]","relat","remov","repl.","requir","reset","reset`","restor","right","run","running,","s","save","script","secureboot,","see","sequenti","ser=py343434","serial","set","shield","show","sigfox","smac","special","specif","specifi","speed","speed,","speed]","speed`","ssid","ssid]","storag","storage.","structur","sub","success","such","support","suppress","sure","switch","system","t","tar","tar,","tar[.gz]","tar]","tell","through","token","token]","tool","tool,","ubuntu","uid","uid]","uniqu","updat","update\\","upgrad","upload","us","us915","usag","usage:","used.","user","userid","util","v","v,","v]","variabl","verbos","verbose`","version","via","vid:pid=04d8:f013","view","volatil","wifi","window","windows:","wire","without","wmac","wob","workaround","write","x","x,","x]","{list,chip_id,wmac,smac,sigfox,exit,flash,copy,write,write_remote,wifi,pybytes,cb,nvs,ota,lpwan,erase_fs,erase_all}"],"advance/encryption.html":["#","#):","$idf_path/components/esptool_py/esptool/espefuse.pi","$idf_path/components/esptool_py/esptool/espsecure.pi","$idf_path/components/esptool_py/esptool/esptool.pi","(0x1a0000)","(at","(bi","(either","(flash_encryption_key.bin","(for","(ignor","(max","(partit","(write","/dev/ttyusb0","0x0","0x0,","0x0f","0x0f)","0x1000).","0x10000","0x1a0000).","0x8000","2","3","80m","921600","abs_done_0","achiev","additionally,","address","address,","address:","along","applic","application)","artifact","avail","base","baud","befor","below","binari","binaries:","bit","board=gpi","boot","boot;","bootload","bootloader,","bootloader.bin","build","build/gpy/release/bootloader/bootload","build/gpy/release/gpy.bin_enc_0x10000","build/gpy/release/lib/partitions.bin_enc","burn","burn_efus","burn_key","burnt","chain","chip","clean","code","code.","command","command:","commands:","compil","complet","configur","default","detail","detect","digest","digest.bin","digest.bin_enc","dio","directori","done","download","efus","efuse,","efuses.","enabl","encrypt","encrypt_key=flash_encryption_key.bin","encrypted,","encrypted.","encrypted;","encryption)","esp32","esp32,","even","extract_public_key","factori","find","firmwar","firmware,","firmware.","firstli","flag;","flash","flash:","flash_crypt_cnt","flash_crypt_config","flash_encrypt","flash_encryption_key.bin","flash_freq","flash_mod","flash_siz","folder","follow","found","gener","generate_flash_encryption_key","generate_signing_key","generated:","gpy.bin_enc_0x10000","gpy.bin_enc_0x1a0000","here,","here.","hint:","image.","instead","instruct","interface,","irrevers","it'","it.","key","key,","key.bin","key.bin)","key.bin,","keyfil","keys,","level","line","locat","main","make","makefil","manual","mechan","method","micropython","more","more,","need","never","next","no_reset","note:","obtain","onc","open","oper","option","option;","or,","order","ota","ota_0","other","paramet","partit","physic","port","pre","prerequisit","process,","protected)","pycom.ota_slot()","python","random","randomli","re","read","reflash","rel","repo.","respond","run","same","secur","secure=on","secure_boot","secure_boot_signing_key.pem","secure_key=secure_boot_signing_key.pem","secureboot","set:","setup","signature_verification_key.bin","sourc","source.","specif","start","summari","target=[boot|app]","target=app","target=boot","termin","this,","times.","togeth","too.","tool","transform","updat","updated.","us","usb)","valu","version","ways:","write_flash","written","written,","z"],"documents/certificates.html":["2.0","3.0","board","ce","certif","certificate\"","certificate.pdf)","develop","fcc","fipi","g01","gpi","l01","lopi","modul","oem","red","sipi","w01","wipi"],"documents/license.html":["(c)","(mit)","(the","2013","2015","2017,","3","abov","action","addit","and/or","aris","associ","author","avail","charge,","claim,","conditions:","connect","contract,","copi","copy,","copyright","damag","damien","deal","distribute,","document","event","express","file","file,","fit","follow","free","from,","furnish","george,","gnu","gpl","granted,","herebi","holder","https://www.pycom.io/opensource/licens","implied,","includ","inform","is”,","kind,","later","liability,","liabl","licenc","licens","limit","limited.","merchantability,","merge,","mit","modify,","more","noninfringement.","notic","obtain","other","otherwise,","out","p.","particular","permiss","permit","person","portion","provid","publish,","purpos","pycom","restriction,","right","see","sell","shall","so,","softwar","software,","software.","subject","sublicense,","substanti","suppli","terms.","tort","under","us","use,","v1.0","version","version,","warranti","whether","without","“a","“software”),"]},"length":177},"tokenStore":{"root":{"0":{"0":{"4":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"5":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"docs":{},":":{"0":{"0":{"docs":{},":":{"0":{"0":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"1":{"0":{"0":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},"docs":{}},"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"2":{"0":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},"4":{"docs":{},"d":{"8":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}},":":{"docs":{},"f":{"0":{"1":{"3":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"4":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}},"8":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"9":{"docs":{},":":{"5":{"1":{"docs":{},":":{"4":{"6":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.01904761904761905},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.02},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.032520325203252036},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.010183299389002037},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.012195121951219513},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"1":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}},"2":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"5":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},"9":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"x":{"0":{"0":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"1":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"f":{"docs":{},"f":{"0":{"0":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}}}},"1":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}},"2":{"0":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"3":{"0":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},"]":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},")":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}},"4":{"0":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},"d":{"8":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"docs":{}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}},"5":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"6":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"7":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"8":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"f":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},")":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"1":{"0":{"0":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}}},"docs":{},")":{"docs":{},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}},"8":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"docs":{},"a":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"2":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}},"docs":{}},"8":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"3":{"0":{"0":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"4":{"0":{"0":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"docs":{}},"2":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}}},"docs":{}},"7":{"7":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},"docs":{},"f":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"c":{"docs":{},")":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"f":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"8":{"0":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"docs":{}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}},"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}},"9":{"5":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025}}}},"docs":{}},"docs":{},"e":{"docs":{},"f":{"3":{"7":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"8":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"9":{"8":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"9":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"docs":{}}},"f":{"0":{"1":{"1":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},"2":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},"3":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"4":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"docs":{}},"1":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"8":{"docs":{},"]":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}},"9":{"docs":{},"]":{"docs":{},"]":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}},"docs":{},"f":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}},"d":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025}}}}}},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.022222222222222223}},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},";":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"d":{"docs":{},"b":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.023668639053254437},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01092896174863388}}},"%":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"}":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"1":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}},"*":{"1":{"0":{"0":{"docs":{},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}}},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"u":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}},"%":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"h":{"docs":{},"z":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"u":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},":":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"m":{"docs":{},"a":{"docs":{},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}},"2":{"4":{"docs":{},"]":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}},"docs":{},".":{"4":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"docs":{}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},":":{"3":{"0":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}},"docs":{}},"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"h":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"m":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}},"a":{"docs":{},".":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889}}}}},",":{"0":{"0":{"0":{"docs":{},"u":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"docs":{}},"docs":{}},"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"%":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"u":{"docs":{},"a":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}},".":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},"k":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}},"1":{"2":{"0":{"docs":{},".":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}},"docs":{}},"5":{"2":{"0":{"0":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"d":{"docs":{},"b":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"2":{"0":{"docs":{},"m":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"2":{"docs":{},"h":{"docs":{},"z":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}},"3":{"4":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},"5":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"8":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"d":{"docs":{},"b":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"3":{"6":{"0":{"4":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}},"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}},"4":{"6":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},":":{"2":{"3":{"docs":{},":":{"5":{"8":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},".":{"0":{"4":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{}},"docs":{}}},"5":{"1":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"6":{"3":{"8":{"4":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"docs":{}},"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}},"\"":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"8":{"0":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{},"d":{"docs":{},"b":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}},"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"1":{"docs":{},".":{"1":{"4":{"4":{"docs":{},":":{"8":{"0":{"0":{"0":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"4":{"docs":{},".":{"1":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}},")":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"7":{"0":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"docs":{}},"docs":{},".":{"7":{"docs":{},"µ":{"docs":{},"a":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}}},"docs":{}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.019851116625310174},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.045454545454545456}},":":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}},".":{"0":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},".":{"0":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"1":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"2":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"9":{"9":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789}}},"docs":{}},"docs":{},"x":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"1":{"2":{"docs":{},".":{"0":{"docs":{},".":{"docs":{},"b":{"0":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}},"docs":{}}}},"docs":{}}},"4":{"docs":{},".":{"3":{"docs":{},")":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"docs":{}}},"6":{"docs":{},".":{"0":{"docs":{},".":{"docs":{},"b":{"1":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602}}},"docs":{}}}},"docs":{},"x":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}},"7":{"docs":{},".":{"0":{"docs":{},".":{"docs":{},"b":{"1":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},"docs":{}}}},"5":{"docs":{},".":{"docs":{},"b":{"6":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{}}}},"docs":{}}},"docs":{},"v":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},",":{"0":{"docs":{},",":{"0":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}},"docs":{}}},"2":{"5":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"docs":{},".":{"5":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"docs":{}}},"4":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"5":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}},".":{"2":{"5":{"4":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"docs":{}},"docs":{}},"docs":{}}},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01953125},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"]":{"docs":{},")":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}}}},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"2":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}},"m":{"docs":{},"g":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"5":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"9":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"m":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}},"1":{"0":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"3":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"4":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"5":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"6":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"7":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"8":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"docs":{}},"4":{"8":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"docs":{}},"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"*":{"1":{"0":{"0":{"docs":{},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{}},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}},"1":{"docs":{},";":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"2":{"4":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}},"docs":{}},"3":{"0":{"4":{"0":{"0":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"4":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"5":{"0":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}},"4":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"5":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"6":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"7":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}},"8":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"9":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.011278195488721804},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.02564102564102564},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},":":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},".":{"0":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":5.004385964912281},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":3.346153846153846},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.03816793893129771}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}},"4":{"docs":{},"g":{"docs":{},"h":{"docs":{},"z":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}}}},"5":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"7":{"docs":{},":":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"x":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"u":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}}},"g":{"docs":{},"/":{"3":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}}}}}}},"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"m":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"a":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"*":{"docs":{},"*":{"docs":{},"e":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}},"3":{"0":{"0":{"docs":{},"k":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"6":{"0":{"7":{"6":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"%":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"1":{"2":{"5":{"docs":{},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}}},"docs":{}},"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},")":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"2":{"7":{"6":{"8":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{}},"9":{"docs":{},"a":{"docs":{},"l":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"7":{"6":{"8":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"docs":{}},"docs":{}},"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},"\"":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"6":{"6":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"docs":{}},"7":{"5":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"7":{"8":{"1":{"docs":{},".":{"docs":{},"d":{"docs":{},"u":{"docs":{},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"'":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"4":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}},"6":{"3":{"8":{"docs":{},".":{"docs":{},"d":{"docs":{},"u":{"docs":{},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},".":{"0":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":5.006896551724138},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":3.3400900900900896},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555}}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}}}}}}}}},"2":{"7":{"6":{"8":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"docs":{}},"docs":{}},"docs":{}},"3":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872}},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"4":{"docs":{},"v":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"5":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"v":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"6":{"docs":{},".":{"5":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}},"x":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},":":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"v":{"3":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}},")":{"docs":{},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}},"docs":{},"p":{"docs":{},"p":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"d":{"docs":{},".":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}},"g":{"docs":{},"p":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"r":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}},"4":{"0":{"9":{"6":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},"docs":{}},"docs":{}},"3":{"3":{"docs":{},"m":{"docs":{},"h":{"docs":{},"z":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}}}}}},"docs":{}},"4":{"3":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},"[":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"docs":{}}}},"docs":{}},"5":{"0":{"docs":{},"m":{"docs":{},"a":{"docs":{},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}},"docs":{}},"8":{"6":{"5":{"6":{"docs":{},"c":{"6":{"docs":{},"c":{"6":{"docs":{},"f":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}},")":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":5.002976190476191},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":5.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},":":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"m":{"docs":{},"b":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862}},".":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}},"s":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}},"/":{"5":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}},"docs":{}},".":{"2":{"docs":{},".":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}},"docs":{}},"k":{"docs":{},"i":{"docs":{},"b":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"5":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"m":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{},"u":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},":":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"docs":{},"%":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"1":{"2":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},"k":{"docs":{},"b":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}}},"docs":{}},"4":{"8":{"5":{"4":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"docs":{}},"docs":{}},"docs":{}},"9":{"9":{"6":{"9":{"3":{"8":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}},"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.016216216216216217},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"docs":{}}},"docs":{}}},"1":{"docs":{},".":{"1":{"docs":{},".":{"0":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577}}},"docs":{}}},"docs":{}}},"5":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"v":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349}},".":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"docs":{}},"t":{"docs":{},"h":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}}},"v":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"6":{"0":{"0":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"4":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},")":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"\"":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"5":{"5":{"3":{"5":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"docs":{}},"docs":{}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"d":{"docs":{},"b":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}},"7":{"0":{"docs":{},"b":{"3":{"docs":{},"d":{"5":{"4":{"9":{"9":{"5":{"8":{"5":{"docs":{},"f":{"docs":{},"c":{"docs":{},"a":{"1":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"1":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"8":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}},"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":2.5076923076923077},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},",":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},".":{"8":{"docs":{},".":{"0":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"docs":{}}},"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"u":{"docs":{},"a":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},"8":{"0":{"0":{"0":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{}},"8":{"0":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},"docs":{}},"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}},"%":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},"[":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"docs":{}}},"m":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"1":{"9":{"2":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}}},"docs":{}},"docs":{}},"4":{"4":{"1":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},"[":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"docs":{}}}},"docs":{}},"9":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},"docs":{}},"6":{"3":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"8":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},"m":{"docs":{},"h":{"docs":{},"z":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"/":{"9":{"1":{"5":{"docs":{},"m":{"docs":{},"h":{"docs":{},"z":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"docs":{}},"7":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"8":{"8":{"3":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"docs":{}},"docs":{}},"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}},"m":{"docs":{},"b":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}},".":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}},"/":{"1":{"0":{"docs":{},"/":{"docs":{},"+":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}},",":{"docs":{"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}}},"docs":{}},"docs":{}},"'":{"docs":{},")":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}}},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"8":{"docs":{},".":{"8":{"docs":{},".":{"8":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"docs":{}}},"docs":{}}},"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"9":{"0":{"2":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},".":{"0":{"docs":{},".":{"3":{"9":{"docs":{},".":{"1":{"docs":{},")":{"docs":{},"]":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"1":{"2":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}},"5":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},"m":{"docs":{},"h":{"docs":{},"z":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"docs":{}},"2":{"1":{"6":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"docs":{}},"6":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"9":{"docs":{},"%":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},")":{"docs":{},":":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"1":{"docs":{},".":{"0":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}},"docs":{}}},"docs":{},"&":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.017142857142857144},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},"a":{"2":{"0":{"docs":{},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}},"docs":{}},"docs":{},"p":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.012962962962962963},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"i":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":5.090909090909091},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":3.3361986628462272},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.0449438202247191},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082}},".":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"n":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}},")":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},".":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"s":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},",":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},".":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}},":":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"u":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}}}},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077}}}}},"l":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},"i":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"c":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.017191977077363897},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.03409090909090909},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.014184397163120567},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.034482758620689655},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"_":{"docs":{},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}}},"s":{"docs":{},"w":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},")":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"i":{"docs":{},"m":{"docs":{},"g":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}},"a":{"docs":{},"r":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"m":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.010126582278481013}}},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.03333333333333333},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0273972602739726},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.027586206896551724},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.026490066225165563},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0547945205479452},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.03333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.05263157894736842},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.05263157894736842},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.02564102564102564},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"_":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"/":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}}}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}},"c":{"docs":{},"c":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.023809523809523808},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.02631578947368421},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.022339027595269383},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.02},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266}}}}},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0106951871657754},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},":":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}},"p":{"docs":{},"t":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.013779527559055118},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00718954248366013},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01366120218579235}},"e":{"docs":{},"d":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.016736401673640166},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955}}},":":{"docs":{"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}}}}},"r":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}}},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}}}}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"u":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"2":{"0":{"0":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}}}}}},"u":{"docs":{},"r":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.024615384615384615}}}}}},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806}},"i":{"docs":{},"v":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},";":{"docs":{"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421}}},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"y":{"docs":{},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},"o":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.00975609756097561}}}}}},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.01240694789081886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{"products.html":{"ref":"products.html","tf":0.04},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.019830028328611898},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.026785714285714284},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.02040816326530612},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.021686746987951807},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.015873015873015872},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"=":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},")":{"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}},"s":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":5.020080321285141},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}}}}}},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}},"d":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.02459016393442623},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"v":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01953125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.01653944020356234},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}},"r":{"docs":{},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}}}}}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.02857142857142857}},"'":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"d":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"pybytes/connect/":{"ref":"pybytes/connect/","tf":3.3745704467353947},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":2.5096153846153846},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":3.3445692883895126},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.021505376344086023},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.014970059880239521}},"(":{"1":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"docs":{}}}}}}}},"r":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.017605633802816902},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.037267080745341616},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02022058823529412},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.02631578947368421},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.018726591760299626},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.014962593516209476}},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02022058823529412},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}},"/":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"\"":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"=":{"0":{"docs":{},"x":{"2":{"3":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"docs":{}},"docs":{}}},"docs":{},"i":{"2":{"docs":{},"c":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}}}}},"docs":{}}}}}}}}}}},"docs":{}}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}},"e":{"docs":{},"=":{"8":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}}},"docs":{}}}}}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.0625},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}},"!":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"c":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":10.080357142857142},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":15.060240963855422},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},"(":{"0":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}},"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},".":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"=":{"docs":{},"'":{"docs":{},"p":{"1":{"3":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}},"6":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"docs":{}},"docs":{}}}}}}},"*":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}}}},"v":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"(":{"1":{"1":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"v":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"2":{"2":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}},"docs":{}},"docs":{}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"n":{"docs":{},"_":{"0":{"docs":{},"d":{"docs":{},"b":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}}}}},"1":{"1":{"docs":{},"d":{"docs":{},"b":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}}}},"docs":{}},"2":{"docs":{},"_":{"5":{"docs":{},"d":{"docs":{},"b":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}}}}},"docs":{}}},"6":{"docs":{},"d":{"docs":{},"b":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}}}}},"docs":{}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}},"_":{"docs":{},"c":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856}},"(":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}},".":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":5.004016064257028}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},"a":{"docs":{},"y":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.00998003992015968},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":10.076923076923077}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}}}}}}}}}}}}}}}}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077}}}}},"i":{"docs":{},"v":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"e":{"docs":{},".":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}}},"e":{"docs":{},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"a":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},".":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}}},"d":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}}}},"c":{"docs":{},"h":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"i":{"docs":{},"v":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602}},"e":{"docs":{},".":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}},"g":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.009398496240601503},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.015772870662460567},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.018461538461538463},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.04644808743169399}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.01342756183745583}}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},",":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"s":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889}}}}}},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}},"l":{"docs":{},"i":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}}},"s":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549}}}},"v":{"docs":{},"e":{"docs":{},".":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}}},"a":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.012944983818770227},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.025787965616045846},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}},"c":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.013377926421404682},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}},".":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}}}}}}},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"e":{"docs":{},"x":{"docs":{},"!":{"docs":{},"\"":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.013477088948787063}}}}},"u":{"docs":{},"m":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"=":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}}}},"s":{"docs":{},"_":{"docs":{},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"1":{"docs":{},"x":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"_":{"docs":{},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"docs":{}}}}}}}}}}}}},"4":{"8":{"docs":{},"x":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"docs":{},"x":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"8":{"docs":{},"x":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"9":{"6":{"docs":{},"x":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"1":{"0":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"3":{"0":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"4":{"0":{"0":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"docs":{}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"1":{"0":{"0":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}}}}}}},"o":{"docs":{},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"a":{"docs":{},"r":{"docs":{},"m":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0220125786163522},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},")":{"docs":{},":":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"s":{"docs":{},".":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}}}}},"s":{"9":{"2":{"3":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{}},"docs":{}},"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}}},"g":{"docs":{},"n":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"e":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176}},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"b":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"w":{"docs":{},"a":{"docs":{},"v":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"u":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"i":{"docs":{},"a":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}},"k":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"r":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"k":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.007339449541284404},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.015189873417721518},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":10.024647887323944}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},"/":{"docs":{},"v":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"n":{"docs":{},"u":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338}}},"d":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},"n":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"=":{"docs":{},"a":{"docs":{},"d":{"docs":{},"c":{"docs":{},".":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"n":{"docs":{},"_":{"0":{"docs":{},"d":{"docs":{},"b":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"1":{"1":{"docs":{},"d":{"docs":{},"b":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"s":{"docs":{},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}},"&":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}},"u":{"9":{"1":{"5":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{}},"docs":{}},"docs":{},"t":{"docs":{},"o":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"m":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.04878048780487805},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},":":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},")":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}}}}}}}}}}},"h":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.015968063872255488},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}},"=":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"_":{"docs":{},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"p":{"docs":{},"a":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"docs":{}}}}}}}}}}}}}}}}},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"p":{"docs":{},"a":{"2":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"'":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"p":{"docs":{},"y":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"'":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}}}},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}},")":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}},"docs":{}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}}},"o":{"docs":{},"r":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"e":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}}},"b":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},"g":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"a":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":5.012422360248447}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02857142857142857}},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}}}}},"w":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":10.013513513513514},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.062111801242236024}},"a":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"e":{"docs":{},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}},"y":{"docs":{"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456}}},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"t":{"docs":{},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"b":{"0":{"0":{"1":{"2":{"3":{"4":{"docs":{},"\"":{"docs":{},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"o":{"docs":{},"v":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"p":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":5.021857923497268},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},"_":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"_":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"docs":{}}}}}}}},"i":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"l":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"c":{"1":{"docs":{},"d":{"docs":{},"e":{"4":{"5":{"docs":{},"b":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}},"docs":{}},"docs":{}}}},"docs":{}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}},"n":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655}}}}}}},"i":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},":":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}},"m":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.05714285714285714}}}},"x":{"docs":{},"i":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223}}}}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},":":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"e":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":10.019762845849803},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"s":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}}}}}}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},"c":{"docs":{},":":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}},"f":{"docs":{},"b":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},":":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}},"r":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}},"t":{"docs":{},"r":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},":":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}},"e":{"docs":{},"c":{"docs":{},"b":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},":":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"g":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"1":{"2":{"8":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},":":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"docs":{}},"docs":{}},"8":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"docs":{}}}}}}}}}}}}},"b":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"e":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.0625},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.014545454545454545},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}},"n":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}},":":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"n":{"docs":{},"g":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"e":{"docs":{},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.006535947712418301},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.030303030303030304},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},"a":{"docs":{},"t":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},"r":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}},")":{"docs":{},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},".":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},":":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},".":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}}},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.015037593984962405},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.01891891891891892},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.012468827930174564}},"/":{"docs":{},"g":{"docs":{},"p":{"docs":{},"y":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"/":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"p":{"docs":{},"y":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"_":{"0":{"docs":{},"x":{"1":{"0":{"0":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},"i":{"docs":{},"n":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":10.035294117647059}}}}}}},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0169971671388102},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.017857142857142856},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.01749271137026239},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.014457831325301205},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.01904761904761905},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.010638297872340425},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.023952095808383235},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},")":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}},".":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"s":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"m":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"y":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},"g":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"f":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.013157894736842105},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}}},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622}}},"e":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},":":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}}},"r":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"_":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"s":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}}}}},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.05263157894736842},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.05263157894736842},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.038461538461538464},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.031746031746031744},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"y":{"docs":{},",":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}}}}},"s":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"c":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},")":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}},"e":{"6":{"4":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.030303030303030304}}},"docs":{}},"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":2.53125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":2.525}}}}}}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409}},"s":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098}},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"b":{"docs":{},"w":{"docs":{},"_":{"1":{"2":{"5":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}},"=":{"2":{"0":{"docs":{},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}},"docs":{}},"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"g":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"c":{"docs":{},"k":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.016736401673640166},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},")":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}},"u":{"docs":{},"p":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/cli.html":{"ref":"advance/cli.html","tf":0.009893992932862191}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"c":{"docs":{},"b":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"n":{"docs":{},"v":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},",":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"r":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825}}}}}}},"e":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"u":{"docs":{},"d":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"=":{"1":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"9":{"6":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}},"g":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":10.0390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":10.024173027989821},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429}},",":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"1":{"2":{"8":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"r":{"docs":{},"v":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"docs":{}},"6":{"docs":{},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"docs":{}},"3":{"2":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"r":{"docs":{},"v":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"docs":{}},"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}},"t":{"1":{"6":{"docs":{},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"docs":{}},"docs":{},"x":{"docs":{},"_":{"docs":{},"p":{"docs":{},"w":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"[":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}},"'":{"1":{"1":{"2":{"2":{"3":{"3":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"f":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"_":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"docs":{}}}}}}},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"_":{"docs":{},"n":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"docs":{}},"2":{"0":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}},"docs":{}},"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"_":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"r":{"docs":{},"s":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"1":{"2":{"3":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"docs":{}},"docs":{}},"docs":{}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"=":{"docs":{},"b":{"docs":{},"'":{"1":{"2":{"3":{"4":{"5":{"6":{"7":{"8":{"9":{"0":{"1":{"2":{"3":{"4":{"5":{"6":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"*":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"'":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}}}},"x":{"docs":{},"t":{"docs":{},"_":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.02112676056338028},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.011976047904191617},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.019704433497536946},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.02185792349726776},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.013108614232209739},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},":":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}}}}},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.02027027027027027},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}},"c":{"docs":{},"k":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"e":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.02734375},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.010178117048346057},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.03773584905660377},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}},"y":{"docs":{},"n":{"docs":{},"k":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}}}}}},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"products.html":{"ref":"products.html","tf":0.03333333333333333},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.019830028328611898},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.020833333333333332},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.02040816326530612},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0220125786163522},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.021686746987951807},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.022222222222222223},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.027777777777777776},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.011009174311926606},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.020253164556962026},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.017605633802816902},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.02304964539007092},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.03333333333333333},"datasheets/boards/":{"ref":"datasheets/boards/","tf":3.444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":3.3806306306306304},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.05263157894736842},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.05263157894736842},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":3.4358974358974357},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}},"s":{"docs":{},",":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}},".":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602}}},"/":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"'":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"=":{"docs":{},"g":{"docs":{},"p":{"docs":{},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.017456359102244388}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"h":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},".":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}},"o":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":5.024305555555555},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.019438444924406047},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.012468827930174564}},"s":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444}}}},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},"p":{"docs":{},"i":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}},"\"":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.010638297872340425},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0199501246882793}},"e":{"docs":{},"r":{"0":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"*":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"2":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"*":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},";":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"k":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},"x":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}},"!":{"docs":{"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},".":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}},"n":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}},"a":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}},"z":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223}}}}}},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}},"w":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}},"i":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"w":{"docs":{},"l":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},"[":{"6":{"docs":{},":":{"docs":{},"]":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},"docs":{},":":{"6":{"docs":{},"]":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"5":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.07575757575757576},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.017391304347826087},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0125},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.0379746835443038},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.026490066225165563},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.009198423127463863},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.028391167192429023},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.03225806451612903},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"s":{"docs":{},"=":{"1":{"2":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},"docs":{}},"8":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}},"docs":{}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},":":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}},"/":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}},"g":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.017964071856287425},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0125},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.019851116625310174},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.008888888888888889},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.02631578947368421},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.02702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.021956087824351298},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.019867549668874173},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.02631578947368421},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.014962593516209476},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.04878048780487805},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.045454545454545456},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.018726591760299626},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"s":{"docs":{},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"(":{"docs":{},"[":{"0":{"docs":{},"x":{"0":{"1":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{}},"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}},"docs":{}},"docs":{}}},"docs":{}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},".":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"(":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"8":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}},"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}}}}},"t":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"_":{"docs":{},"o":{"docs":{},".":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}},"h":{"1":{"7":{"5":{"0":{"docs":{},"f":{"docs":{},"v":{"docs":{},"i":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.023809523809523808}},".":{"docs":{},"b":{"docs":{},"h":{"1":{"7":{"5":{"0":{"docs":{},"f":{"docs":{},"v":{"docs":{},"i":{"docs":{},"(":{"docs":{},"i":{"2":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}}}}},"docs":{}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"p":{"docs":{},"y":{"docs":{},".":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"%":{"docs":{},"d":{"docs":{},"s":{"docs":{},".":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.017369727047146403}}},"'":{"4":{"5":{"6":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}},"docs":{}},"docs":{}},"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{},":":{"docs":{"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"'":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}}}}}}}}}}},"w":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}},"d":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"f":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"p":{"docs":{},"o":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}}},"d":{"0":{"docs":{},"d":{"docs":{},"c":{"7":{"0":{"8":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}},"v":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516}},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.04819277108433735},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.017045454545454544},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/":{"ref":"datasheets/development/","tf":5.111111111111111},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}}}}}}}}}},"u":{"docs":{},"i":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.024844720496894408},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.034722222222222224},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.012844036697247707},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.01680672268907563},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.021052631578947368},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.017361111111111112},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":5.105263157894737},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.058577405857740586},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.029069767441860465},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.04011461318051576},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.05397727272727273},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.02112676056338028},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.01567398119122257},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.013623978201634877},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.024844720496894408},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.0625},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.02127659574468085},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.02564102564102564},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/":{"ref":"tutorials/all/","tf":3.4999999999999996},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.01675977653631285},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.009216589861751152},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0390625},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.015202702702702704},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.02},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.01920768307322929},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.03571428571428571},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.011450381679389313},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.03773584905660377},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.014962593516209476},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.011461318051575931},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.031746031746031744},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176},"pybytes/connect/":{"ref":"pybytes/connect/","tf":3.4570446735395186},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.0673076923076923},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.061855670103092786},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":3.3782771535580522},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.08064516129032258},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.11475409836065574},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":3.3512974051896203},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.07142857142857142},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.031055900621118012},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}},"e":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.03614457831325301},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"s":{"docs":{},":":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}}}},"'":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.021052631578947368},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.022058823529411766},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.020618556701030927},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},"!":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},":":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.014285714285714285},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.009925558312655087}}},")":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}}},"\"":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},";":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}},"k":{"docs":{},"i":{"docs":{},"t":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":5.016129032258065}}}}}},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}}}}}}},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512}}}}},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"c":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}}}}}}},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}},"e":{"docs":{},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.008888888888888889},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.02631578947368421},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.026200873362445413},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.02666666666666667},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":3.4705882352941173},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":3.364851957975167}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915}},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}},"o":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"w":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},":":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},":":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},":":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.008595988538681949}}}}}}}}}}},"f":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0225},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.015789473684210527},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.018633540372670808},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.011278195488721804},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.013972055888223553},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"advance/cli.html":{"ref":"advance/cli.html","tf":0.005653710247349823},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}},"i":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.00788436268068331},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.017964071856287425}},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"r":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}}},"b":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.03424657534246575},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"t":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"r":{"docs":{},"o":{"docs":{},"y":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.041666666666666664},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"t":{"docs":{},"h":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"e":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}},"e":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"t":{"docs":{},"a":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}},"i":{"docs":{},"v":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}},"m":{"docs":{},"o":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"b":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"u":{"docs":{},"g":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}}},"o":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"c":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.11428571428571428},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}}},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}}}}}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},")":{"docs":{},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"u":{"docs":{},"b":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"l":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}}}}},"n":{"docs":{},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},"!":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"'":{"docs":{},"t":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"'":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"w":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.024844720496894408},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.020833333333333332},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.03076923076923077},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.02577319587628866},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.00997506234413965}},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"_":{"docs":{},"h":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":5.019607843137255}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}},"'":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"z":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334}},"(":{"docs":{},"\"":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},":":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"l":{"docs":{},"i":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}}},"y":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.018633540372670808},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}},"y":{"docs":{},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.03111111111111111}}},")":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"f":{"docs":{},"f":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}}}}},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"g":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"o":{"docs":{},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"e":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015}}}}}}}}}},"v":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"(":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},",":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}}}}},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"y":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}},"a":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}},"v":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},"o":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"r":{"docs":{},"i":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"v":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889}},"r":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":10.06832298136646},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.014184397163120567},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":2.576923076923077},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":5.0025},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.09523809523809523},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.030612244897959183}},"s":{"docs":{},";":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},":":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},".":{"docs":{"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"'":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},",":{"docs":{},"'":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"'":{"docs":{},":":{"docs":{},"'":{"3":{"2":{"3":{"6":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"'":{"docs":{},":":{"docs":{},"'":{"1":{"3":{"0":{"1":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"n":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"o":{"docs":{},"p":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385}}}}}}}},"a":{"docs":{},"w":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}}},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}},"g":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}},"=":{"0":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"_":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"=":{"6":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"=":{"5":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}}},"a":{"docs":{},"m":{"docs":{},"a":{"docs":{},"g":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"t":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"docs":{},"a":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.022653721682847898},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.02734375},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.014285714285714285},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.012004801920768308},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.013257575757575758},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.028368794326241134},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.03940886699507389},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.04371584699453552},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.013513513513513514},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.00998003992015968},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.018329938900203666},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.017811704834605598},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.03125},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00718954248366013},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.012903225806451613},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.01079913606911447},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.07575757575757576},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.020599250936329586},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.08695652173913043},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.04411764705882353},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":3.3512974051896203},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.020689655172413793},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.024},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.07894736842105263},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.07894736842105263},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.030612244897959183},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.038461538461538464}},"s":{"docs":{},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112}}}}}}}}},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"[":{"6":{"docs":{},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"7":{"docs":{},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{},"i":{"docs":{},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},".":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"=":{"docs":{},"b":{"docs":{},"'":{"1":{"2":{"3":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"docs":{}},"docs":{}},"docs":{}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"[":{"0":{"docs":{},"x":{"0":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}},"docs":{}},"docs":{}}},"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"e":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.01775147928994083}},"e":{"docs":{},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"/":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}},"y":{"docs":{},"s":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}},"c":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":10.071428571428571}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"docs":{}}},"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}}}}}}}}},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"1":{"0":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"w":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}},"s":{"docs":{},"h":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617}},";":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"!":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},".":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}},"'":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}}}},"c":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666}}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}},"a":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.022727272727272728},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.03054989816700611},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"[":{"docs":{},"i":{"docs":{},"]":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}}}}},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}},"e":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}},"a":{"docs":{},"l":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"e":{"docs":{},"x":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"_":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}},"e":{"docs":{},"=":{"0":{"docs":{},".":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018}}}},"docs":{}}},"docs":{}}}}}}}}},"i":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.032520325203252036},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"'":{"docs":{},",":{"docs":{},"'":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"0":{"0":{"5":{"4":{"docs":{},"e":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"f":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0673758865248227},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},"s":{"1":{"8":{"docs":{},"b":{"2":{"0":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"docs":{}},"docs":{}},"x":{"2":{"0":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}},"(":{"docs":{},"o":{"docs":{},"w":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"1":{"7":{"docs":{},"'":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"docs":{}},"docs":{}}},"[":{"docs":{},"'":{"docs":{},"p":{"1":{"7":{"docs":{},"'":{"docs":{},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"1":{"7":{"docs":{},"'":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"docs":{}},"docs":{}}},"[":{"docs":{},"'":{"docs":{},"p":{"1":{"7":{"docs":{},"'":{"docs":{},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}},"o":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"6":{"0":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"h":{"docs":{},"c":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}},"t":{"1":{"1":{"docs":{},"/":{"docs":{},"d":{"docs":{},"h":{"docs":{},"t":{"2":{"2":{"docs":{},"/":{"docs":{},"a":{"docs":{},"m":{"2":{"3":{"0":{"2":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}},"b":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"m":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"e":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":5.009708737864078},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.041666666666666664},"tutorials/all/":{"ref":"tutorials/all/","tf":3.4999999999999996},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.009603841536614645},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364},"tutorials/lora/":{"ref":"tutorials/lora/","tf":5.009615384615385},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":5.004464285714286},"tutorials/lte/":{"ref":"tutorials/lte/","tf":5.016666666666667},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":5.037037037037037},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":5.037037037037037},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":5.0375},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01912568306010929},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"s":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},":":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.01079913606911447},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},";":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"l":{"docs":{},"i":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"y":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0169971671388102},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.017857142857142856},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.01749271137026239},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.01927710843373494},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.01904761904761905},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.014084507042253521},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/boards/":{"ref":"datasheets/boards/","tf":3.4999999999999996},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":3.3738738738738734},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":3.423076923076923},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.031746031746031744},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}},"d":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"l":{"docs":{},"i":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}}}},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.016181229773462782},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"i":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},".":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}},"s":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.022922636103151862},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.07142857142857142}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}},"n":{"docs":{},"s":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.02054794520547945}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}}}}},"d":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"c":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"_":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"s":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"c":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"p":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.016666666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},";":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}},".":{"docs":{},".":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0176678445229682}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"s":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}},"s":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}},"y":{"docs":{},".":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}}},"i":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},"r":{"docs":{},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}},"l":{"docs":{},"i":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}}}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"p":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.01152073732718894}}}},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.024096385542168676},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.013368983957219251},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.01511879049676026},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}},"e":{"docs":{},".":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}},"d":{"docs":{},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"_":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"(":{"docs":{},"i":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"l":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}},"s":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}},"i":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}},"r":{"docs":{},"i":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.03162055335968379},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023},"advance/encryption.html":{"ref":"advance/encryption.html","tf":5.032418952618454}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"=":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},";":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}},"o":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.045454545454545456},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"d":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.012004801920768308},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"=":{"docs":{},"\"":{"docs":{},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208}},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}},".":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}}}}},"d":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415}},"g":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},"e":{"docs":{},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}}}}},"i":{"docs":{},"t":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"o":{"docs":{},"r":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}},"s":{"docs":{},",":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05}}}},"'":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.00984251968503937},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.03428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00522875816993464},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.022900763358778626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.022900763358778626}},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},".":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},":":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.011363636363636364},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.01445466491458607},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.046153846153846156},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},":":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},"v":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"c":{"docs":{},"t":{"docs":{},"r":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872}},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}},"i":{"docs":{},"f":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"s":{"docs":{},"e":{"docs":{},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}}}}}}},"t":{"docs":{},"c":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},")":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},";":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}}}},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},".":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},"i":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},"o":{"docs":{},"w":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176}}}}},"u":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.045454545454545456}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}}}}},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},"o":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}}},"u":{"8":{"6":{"8":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"i":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.022727272727272728}},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"a":{"docs":{},"t":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}},"a":{"docs":{},"s":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}},"f":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}}}}}},"p":{"3":{"2":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"'":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}},")":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"docs":{}},"docs":{},"b":{"docs":{},"a":{"docs":{},"u":{"docs":{},"d":{"docs":{},"*":{"docs":{},"*":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"*":{"docs":{},"*":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"'":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"t":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}}}}},"d":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}}},"f":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},".":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"e":{"docs":{},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"s":{"docs":{},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},"o":{"docs":{},"f":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"p":{"docs":{},"o":{"docs":{},"c":{"docs":{},"h":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},":":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"f":{"0":{"1":{"4":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"docs":{}},"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"a":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"i":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"v":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}}}}}},"i":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}},".":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"u":{"docs":{},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}},"s":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"h":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}}},"r":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},"c":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},"o":{"docs":{},"r":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504}},"i":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"y":{"docs":{},".":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"'":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},"i":{"docs":{},"l":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"l":{"docs":{},"s":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"e":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},".":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"l":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.011461318051575931}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}}}}},"t":{"1":{"6":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}},"/":{"3":{"2":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}},"docs":{}},"docs":{}}},"docs":{}},"3":{"2":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"docs":{}},"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.05263157894736842},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},":":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"/":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}}}}}}}}}}}}}}}}},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}},";":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"d":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.06086956521739131},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}},"w":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"d":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}},"b":{"docs":{},"r":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"l":{"docs":{},"i":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"q":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"y":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"=":{"5":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"6":{"8":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"9":{"1":{"2":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},")":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"t":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}}}}}}},"o":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"z":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"(":{"docs":{},"[":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}},"m":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.011811023622047244}},".":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"=":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}},"i":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"n":{"docs":{},"d":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"a":{"docs":{},"l":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}}}}},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"t":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}},"p":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":10.043373493975903},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":10.066225165562914},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.05343511450381679}}},"y":{"docs":{},",":{"docs":{"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},".":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555}}},":":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},")":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}},"r":{"docs":{},"m":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.024096385542168676},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":5.041666666666667},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.029288702928870293},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.010126582278481013},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":5.0177304964539005},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":3.3635709143268535},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.029411764705882353},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.07692307692307693},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.03278688524590164},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":5.071895424836601},"advance/cli.html":{"ref":"advance/cli.html","tf":0.009187279151943463},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"e":{"docs":{},",":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},";":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}},"_":{"1":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}},"1":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}},"l":{"docs":{},"i":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525}}}},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":3.340672782874617},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.00788436268068331},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"l":{"docs":{},"i":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},")":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},"=":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"p":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}}}}},"x":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}}},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}},"l":{"docs":{},"e":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.02112676056338028},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.01834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.018292682926829267},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.02452316076294278},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.03205128205128205},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.01680672268907563},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.020518358531317494},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.03125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.03333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0196078431372549},"advance/cli.html":{"ref":"advance/cli.html","tf":0.022614840989399292},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},",":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.03508771929824561},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.03225806451612903},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.031746031746031744},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"z":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}}}}}},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"\\":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"=":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}}},"l":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.013779527559055118}},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.017082785808147174}},"s":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"t":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"f":{"docs":{},"o":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"/":{"docs":{},"b":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.024096385542168676},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.016181229773462782},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.01838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.022222222222222223},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.00984251968503937},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.008905852417302799},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.023411371237458192},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.02181818181818182},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.01951219512195122},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.022727272727272728},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863}}}}}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}},"l":{"docs":{},"l":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}},"i":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},",":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.00755939524838013},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.692439862542955},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0196078431372549},"advance/cli.html":{"ref":"advance/cli.html","tf":0.007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.04239401496259352}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789}}},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}}}}}}}}}}}}}},"!":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"_":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"n":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}},"g":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.01079913606911447},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806}}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},";":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"v":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"o":{"docs":{},"w":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"a":{"docs":{},"t":{"3":{"2":{"docs":{},")":{"docs":{},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"docs":{}},"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.018867924528301886},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},";":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.02112676056338028},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.01567398119122257},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.01634877384196185},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},")":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464}}},":":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"!":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},",":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}},".":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}},"r":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},".":{"docs":{},".":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}}}}}},"m":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.020689655172413793},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.040983606557377046},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446}}}}},"s":{"docs":{},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},":":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},".":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}}}}}}}},"u":{"docs":{},"m":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"?":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},"c":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}}}}},"t":{"docs":{},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":10.067073170731707},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}},"/":{"docs":{},"/":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}},">":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"d":{"docs":{},"i":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"b":{"docs":{},"_":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075}}}}}}},"s":{"1":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{},"k":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.008728179551122194}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"m":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}}}}}}}}},"c":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.16030534351145037}}}},":":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"f":{"docs":{},"i":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},"p":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}},"m":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}},".":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164}}}}},"w":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.022614840989399292}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"g":{"0":{"1":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":10.123287671232877},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.04580152671755725}},")":{"docs":{"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},".":{"docs":{"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693}}},":":{"docs":{"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}},",":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}},"docs":{}},"1":{"docs":{},"d":{"8":{"docs":{},"b":{"5":{"docs":{},"e":{"5":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"docs":{}}},"docs":{}}},"docs":{}}},"2":{"3":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":3.356060606060606}},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"_":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}},"r":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}}}},"u":{"docs":{},"i":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"d":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.02531645569620253},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.01904761904761905},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":5.00253164556962},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}},"e":{"docs":{},",":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},".":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}},"p":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.01904761904761905},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}},"i":{"0":{"8":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},"9":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},"docs":{}},"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":10.040880503144654},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":10.068965517241379},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.04580152671755725}},"o":{"1":{"6":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}},"docs":{}},"2":{"1":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}},"docs":{}},"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.011111111111111112},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"=":{"docs":{},"\"":{"docs":{},"p":{"2":{"0":{"docs":{},"\"":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364}}}}},"docs":{}},"docs":{}}}},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}},"y":{"docs":{},",":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931}}},".":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"_":{"0":{"docs":{},"x":{"1":{"0":{"0":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"a":{"0":{"0":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}},":":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931}}},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"p":{"docs":{},"i":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"s":{"docs":{},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"l":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"o":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.06818181818181818},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"n":{"docs":{},"e":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}},"e":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}},"o":{"docs":{},"d":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}},"g":{"docs":{},"l":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"e":{"docs":{},"'":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}}}},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"f":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.024844720496894408}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"n":{"docs":{},"d":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"w":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}}},"e":{"docs":{},"n":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}},"i":{"docs":{},"d":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}},"u":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},"n":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.017964071856287425},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.009198423127463863},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},",":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"l":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},":":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"t":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.034383954154727794},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.014778325123152709},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":2.5049627791563274},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}}},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":10.0625},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.026490066225165563},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":10.00943396226415}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":10.006622516556291}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":10.012658227848101}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":10.005714285714285}},"i":{"docs":{},"c":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":10.008771929824562}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273}}}}},"r":{"docs":{},"b":{"docs":{},"a":{"docs":{},"g":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.0975609756097561},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"y":{"docs":{},"p":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"c":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":10.024390243902438}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}},")":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}},".":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}}}}}}}}}}},"b":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"m":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"h":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"advance/cli.html":{"ref":"advance/cli.html","tf":0.02756183745583039}},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"(":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"l":{"docs":{},"o":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"r":{"docs":{},"e":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{},".":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}},":":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},".":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}},"\"":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}},"'":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"b":{"docs":{},"i":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"t":{"docs":{},"z":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.012958963282937365}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"s":{"docs":{},",":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}}}}}},"p":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.013377926421404682},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.07317073170731707}},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}},"x":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"m":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.045454545454545456}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},")":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":5.03125},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.09523809523809523},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"v":{"docs":{},"e":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"l":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818}},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.03636363636363636}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},"_":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}},"docs":{}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},"g":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"l":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}},"f":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}}},"s":{"docs":{},"h":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.034782608695652174},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},",":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}},".":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"_":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}}}}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"l":{"docs":{},"i":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},")":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}},"s":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"l":{"docs":{},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},"s":{"docs":{},"/":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}},"y":{"docs":{},":":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}}}},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}},"e":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}}},"d":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"e":{"docs":{},"r":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"w":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.008445945945945946}},"/":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"m":{"docs":{},"e":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"w":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}},"u":{"docs":{},"r":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"n":{"docs":{},"g":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":10.018518518518519},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012}},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"2":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{},"/":{"docs":{},"/":{"1":{"2":{"7":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},":":{"8":{"0":{"0":{"0":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"?":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"1":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"p":{"docs":{},"/":{"docs":{},"d":{"docs":{},"f":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"1":{"docs":{},".":{"0":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}}}}}}}}}},"1":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}},"docs":{}}},"docs":{}}}}},"u":{"docs":{},"m":{"docs":{},"i":{"docs":{},"d":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.013477088948787063}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"n":{"docs":{},"d":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"z":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"advance/cli.html":{"ref":"advance/cli.html","tf":0.012720848056537103}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.02181818181818182}}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.012720848056537103}}}},"i":{"2":{"docs":{},"c":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":10.028571428571428},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":10.043233082706767},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},"(":{"0":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"docs":{}},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}},".":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},"(":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"2":{"docs":{},"c":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}}}}},"docs":{}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"0":{"docs":{},"x":{"4":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"docs":{}},"docs":{}}},"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"(":{"0":{"docs":{},"x":{"4":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}},"docs":{}},"docs":{}}},"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"0":{"docs":{},"x":{"4":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}},"docs":{}},"docs":{}}},"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},"=":{"0":{"docs":{},"x":{"4":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}},"_":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"(":{"0":{"docs":{},"x":{"4":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}},"docs":{}},"docs":{}}},"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}},";":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"r":{"docs":{},"m":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.023411371237458192},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"”":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}},"a":{"docs":{},"l":{"docs":{},".":{"docs":{"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}}}}}}}}}}}},",":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517}}},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"y":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273}}}}}}}}},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.013368983957219251},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"t":{"docs":{"./":{"ref":"./","tf":10.02127659574468},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":10.00632911392405},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":5.007042253521127},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":10.003703703703703},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":10.01388888888889},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":10.006849315068493},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":10.045454545454545},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":10.007352941176471},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":10.028571428571428}}}}}}}},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616}}}},"\"":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.07142857142857142}}}}},"n":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"e":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.013333333333333334},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.011037527593818985},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.07272727272727272},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.008595988538681949}},"s":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},";":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},".":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"o":{"docs":{},"g":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"v":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259}},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}},"g":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.02631578947368421},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"r":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":10.071428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.031055900621118012}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.031055900621118012},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.020253164556962026},"pymakr/installation/":{"ref":"pymakr/installation/","tf":10.05},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.03169014084507042},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.0219435736677116},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":5.03125},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.02127659574468085},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":2.546153846153846},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":5.006410256410256},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078}}}}},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},".":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}},"c":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}},"e":{"docs":{},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}},")":{"docs":{},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},":":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}},":":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"i":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.025925925925925925},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"documents/license.html":{"ref":"documents/license.html","tf":0.022900763358778626}},"e":{"docs":{},":":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}},"s":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"a":{"docs":{},"s":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213}}},"a":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"o":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}}}}},"m":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"x":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"u":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"p":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02022058823529412},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},",":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"_":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"1":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},"s":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}},"/":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},"i":{"docs":{},"t":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.02586206896551724},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}},":":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.025454545454545455},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}},"n":{"docs":{},"t":{"docs":{},"!":{"docs":{"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}}}}}},"o":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}}}}}}},"o":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905}},"t":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.014457831325301205},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.03333333333333333},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":5.033898305084746},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.010752688172043012},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":5.012422360248447}},".":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},",":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},":":{"docs":{"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}}}},"n":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}}},"p":{"6":{"7":{"docs":{"products.html":{"ref":"products.html","tf":0.02}}},"docs":{}},"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.018633540372670808},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.01152073732718894},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.016483516483516484},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},"v":{"4":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"docs":{}}},"t":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"e":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"r":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}}},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}},"'":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"'":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"!":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.015873015873015872},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}}}}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},"o":{"1":{"4":{"4":{"4":{"3":{"docs":{},"a":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"y":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}}}}},"”":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.01834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.017045454545454544},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.016042780748663103},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.020737327188940093},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.02734375},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.07407407407407407},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.0380952380952381},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.05238095238095238},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.015},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.05},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.04225352112676056},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.026143790849673203},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.02666666666666667},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.009603841536614645},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.013257575757575758},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.028368794326241134},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.019704433497536946},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.02185792349726776},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.019851116625310174},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.05660377358490566},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.02197802197802198},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.10185185185185185},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0625},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.008905852417302799},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.009150326797385621},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.02591792656587473},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.03125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01639344262295082},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"/":{"docs":{},"u":{"docs":{},"s":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},"p":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.007202881152460984},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0273972602739726},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.022222222222222223}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}},"a":{"docs":{},"g":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"e":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"s":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"i":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"e":{"docs":{},"i":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":5.043478260869565},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}},".":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.009198423127463863},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.017191977077363897},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},":":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"d":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.03765690376569038},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.014326647564469915},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.015957446808510637},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"a":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},"l":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},"n":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.013779527559055118},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"t":{"docs":{},"y":{"docs":{},"=":{"docs":{},"'":{"docs":{},"m":{"docs":{},"y":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}},"l":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},"e":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182}}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}},")":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},":":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"x":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"=":{"0":{"docs":{},"x":{"1":{"2":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"docs":{}},"docs":{}}},"docs":{}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}},"f":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}}}},"/":{"docs":{},"o":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},")":{"docs":{},")":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},"r":{"docs":{},"q":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}},"q":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"c":{"docs":{},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"o":{"docs":{},"n":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"v":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.019762845849802372}},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}}}},"j":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.027777777777777776},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.02564102564102564},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.014204545454545454},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.019704433497536946},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00718954248366013}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{},".":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.08888888888888889}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"n":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"m":{"1":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.05},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":5.021978021978022},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},"n":{"docs":{},"b":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}}},"/":{"docs":{},"n":{"docs":{},"b":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603}}}}},",":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781}},"o":{"docs":{},"d":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"u":{"docs":{},"l":{"docs":{"products.html":{"ref":"products.html","tf":0.02},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.02531645569620253},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.0625},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.025495750708215296},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.023809523809523808},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.026239067055393587},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.025157232704402517},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.01927710843373494},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.02857142857142857},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":5.0285714285714285},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.011009174311926606},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.024305555555555556},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.029069767441860465},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.012658227848101266},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.018633540372670808},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":5.043478260869565},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.06164383561643835},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":5.107142857142857},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.09523809523809523},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":5.057142857142857},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.09090909090909091},"datasheets/development/":{"ref":"datasheets/development/","tf":5.055555555555555},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.017543859649122806},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.017467248908296942},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.017777777777777778},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/":{"ref":"datasheets/oem/","tf":5.076923076923077},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}},"e":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.03333333333333333},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}},"/":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},".":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},":":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},")":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"'":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"'":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"u":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.010638297872340425},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.028846153846153848},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.012962962962962963},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.009150326797385621},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.007481296758104738},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},".":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"m":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":3.347372210223182},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.01935483870967742},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},".":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"'":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}},".":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}},",":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},";":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},")":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"s":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},";":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},":":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"=":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391}},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"l":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}},"i":{"docs":{},"f":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}},"e":{"docs":{},"d":{"docs":{},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"y":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"b":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":10.014705882352942}},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.017391304347826087},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},")":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},":":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"(":{"docs":{},"s":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}},"n":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"i":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},"s":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}}}},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}},"'":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}}}},"d":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.03333333333333333},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":5.049295774647887},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":5.006472491909385},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.01675977653631285},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0410958904109589},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":5.0285714285714285},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":10.013377926421406},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.022082018927444796},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}},";":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"_":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"p":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}},"k":{"docs":{},"b":{"docs":{},"d":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"[":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"[":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"[":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"g":{"docs":{},"p":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"p":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}},"m":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"i":{"docs":{},"s":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}},"u":{"docs":{},"m":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"u":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"d":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}},"o":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},")":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"f":{"docs":{},"a":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744}}}}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"s":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},".":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}},"t":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.014778325123152709},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01639344262295082},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.022443890274314215}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.012195121951219513}}}}}},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712}}}}},"l":{"docs":{},"i":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}},"c":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":2.5141843971631204},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":2.502481389578164},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},"o":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"x":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}},":":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}}}}}}},":":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.013257575757575758},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.027777777777777776},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":10.008888888888889},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"=":{"2":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}}}},"3":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"docs":{}},",":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"docs":{}}}}},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}},"i":{"2":{"docs":{},"c":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}},"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}},"d":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}},"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}},"l":{"docs":{},"p":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"(":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},"[":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"2":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"2":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"docs":{}},"docs":{}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}},"(":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"_":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}},"n":{"docs":{},"y":{"docs":{},"_":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}},"d":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}},"docs":{}}}}}}}},"a":{"docs":{},"d":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},"docs":{}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}}}}}}}}}},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"s":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"=":{"docs":{},"'":{"docs":{},"g":{"docs":{},"p":{"docs":{},"i":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"r":{"docs":{},"o":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}}}},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}},"'":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815}}}}}}},"i":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"f":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.008403361344537815}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"u":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01171875},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"=":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"_":{"docs":{},"v":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"docs":{}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.676975945017182},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464}}}}},",":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"j":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}},"x":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"=":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"d":{"docs":{},"e":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}},"p":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.05555555555555555},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}}}}}},"h":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":10.007272727272728}},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},".":{"docs":{},"a":{"docs":{},"c":{"docs":{},"o":{"docs":{},"s":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"2":{"docs":{},"(":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}}},"s":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},"r":{"docs":{},"f":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"c":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"x":{"docs":{},"p":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"m":{"1":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"docs":{}}}}},"f":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"r":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"o":{"docs":{},"g":{"1":{"0":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"docs":{}},"2":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"p":{"docs":{},"i":{"docs":{},":":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"q":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.013157894736842105},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}},"/":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},":":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}},"k":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"r":{"docs":{},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"l":{"docs":{},"e":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.018796992481203006},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.01079913606911447},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.013140604467805518},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"'":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.01904761904761905},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.013477088948787063},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.020080321285140562},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.011037527593818985},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0058823529411764705},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.02608695652173913},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.012307692307692308},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.05730659025787966},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.04371584699453552},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},")":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"n":{"docs":{},"u":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"a":{"docs":{},"n":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},"e":{"docs":{},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"i":{"docs":{},"s":{"docs":{},"m":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.009925558312655087},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.026785714285714284},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.023622047244094488},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.008728179551122194},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.01342756183745583}},"e":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},"\"":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"!":{"docs":{},"\"":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"s":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}}}},"h":{"docs":{"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":5.117647058823529}}}},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{},"m":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}},"x":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}}}}},"e":{"docs":{},"x":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"'":{"docs":{},"]":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"p":{"docs":{},"l":{"3":{"1":{"1":{"5":{"docs":{},"a":{"2":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"f":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},"r":{"docs":{},"c":{"6":{"3":{"0":{"0":{"2":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}},"docs":{}},"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"f":{"docs":{},"r":{"docs":{},"c":{"6":{"3":{"0":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"o":{"1":{"4":{"4":{"4":{"3":{"docs":{},"a":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}},"w":{"docs":{},"u":{"docs":{},"p":{"docs":{},"a":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"a":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"m":{"docs":{},"f":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}},"p":{"docs":{},"i":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{},"(":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"o":{"1":{"4":{"4":{"4":{"3":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"a":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}},"w":{"docs":{},"u":{"docs":{},"p":{"docs":{},"a":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"m":{"docs":{},"f":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"_":{"docs":{},"b":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"g":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":10.047619047619047},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.013513513513513514},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},".":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}}}},"s":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"g":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},":":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"=":{"docs":{},"\"":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}},"[":{"docs":{},":":{"1":{"6":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}},"docs":{}},"docs":{}}}},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"b":{"docs":{},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"c":{"docs":{},"u":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"/":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"n":{"docs":{},"b":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}}}},"v":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"y":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"1":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"1":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"docs":{}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"d":{"5":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.017391304347826087}}},"docs":{},"a":{"docs":{},"y":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"p":{"1":{"0":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"1":{"docs":{},"=":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}}}}},"2":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},",":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}},"3":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"4":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"5":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"6":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"7":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"8":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},".":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"9":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}},"2":{"0":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"1":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"2":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.026785714285714284},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"3":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},":":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"3":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"4":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},":":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"6":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},"8":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},":":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}},"/":{"docs":{},"g":{"1":{"5":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"docs":{}},"docs":{}}}},"9":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.01696113074204947}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"t":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"products.html":{"ref":"products.html","tf":5.013333333333334},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"s":{"docs":{},",":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}},".":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},",":{"docs":{"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":3.353516819571865},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},")":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":5.019047619047619},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}}}},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"a":{"docs":{},"t":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.029069767441860465},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.024844720496894408},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.00975609756097561},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}}},"d":{"docs":{},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}}}}}},"s":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.019886363636363636},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}}},"e":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}},"c":{"docs":{},"e":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"s":{"docs":{},"s":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.024096385542168676},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"o":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},":":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"d":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"e":{"docs":{},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},")":{"docs":{},".":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},")":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"s":{"docs":{},".":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"l":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"t":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}}},"h":{"docs":{},"i":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}},"e":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},":":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"c":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"r":{"docs":{},"v":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789}}}}},"s":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0223463687150838},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"u":{"docs":{},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.013477088948787063}},"e":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"s":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}}}}}},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}},"e":{"docs":{},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}}}},"i":{"docs":{},"x":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}}},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},"e":{"docs":{},"=":{"8":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.00998003992015968},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.020066889632107024},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.045454545454545456}},"(":{"1":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}}},"docs":{},"\"":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"i":{"docs":{},"m":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},":":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"p":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}},"e":{"docs":{},"s":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"i":{"docs":{},"n":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"o":{"docs":{},"w":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}},"%":{"0":{"2":{"docs":{},"d":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"docs":{}},"docs":{}},"\\":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},"r":{"docs":{},"%":{"7":{"docs":{},"d":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"n":{"docs":{},"o":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}},"{":{"docs":{},"}":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"g":{"docs":{},"o":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"[":{"docs":{},"'":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"'":{"docs":{},"]":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"_":{"docs":{},"c":{"docs":{},".":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"[":{"2":{"docs":{},"]":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"docs":{}}}}}}}}}},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}}}},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"f":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}}}}}}}}}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}},"x":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"f":{"docs":{},"g":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}},"l":{"docs":{},"t":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}},"o":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"o":{"docs":{},"i":{"docs":{},"l":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}},"u":{"docs":{},"n":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"a":{"docs":{},"w":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}},"d":{"docs":{},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}},"\\":{"docs":{},"n":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}},"{":{"docs":{},"}":{"docs":{},",":{"docs":{},"{":{"docs":{},"}":{"docs":{},"'":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},",":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"_":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"s":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"4":{"0":{"9":{"6":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}},"docs":{}},"docs":{}},"docs":{}},"6":{"4":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}},"docs":{}},"docs":{}}}}}}},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}},"s":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{},".":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}}}}},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"o":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}},"v":{"docs":{},"a":{"docs":{},"c":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}},"l":{"docs":{},"i":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}},"y":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.058823529411764705},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":3.3787878787878785},"pybytes/connect/":{"ref":"pybytes/connect/","tf":3.4054982817869415},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.057692307692307696},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.7439862542955324},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.026881720430107527},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.04918032786885246},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},"e":{"docs":{},"s":{"docs":{},"?":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},".":{"docs":{"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.045454545454545456},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.017964071856287425},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}},":":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":2.5096153846153846},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.6718213058419242}}},";":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},")":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}}},":":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}},".":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}},"s":{"docs":{},"b":{"docs":{},"_":{"docs":{},"v":{"docs":{},"c":{"docs":{},"p":{"docs":{},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"products.html":{"ref":"products.html","tf":5.02},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.07228915662650602},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.01904761904761905},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.012844036697247707},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.031578947368421054},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.017605633802816902},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.01634877384196185},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.06944444444444445},"tutorials/all/":{"ref":"tutorials/all/","tf":3.4999999999999996},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.04225352112676056},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.007202881152460984},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":5.107142857142857},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":10.023758099352051},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.02005730659025788},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.022058823529411766},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.019787985865724382},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"[":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"(":{"docs":{},"[":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"g":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"0":{"docs":{},"x":{"0":{"0":{"0":{"0":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}},"docs":{}},"1":{"5":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"docs":{}},"docs":{}},"docs":{}},"7":{"docs":{},"f":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}},"docs":{}},"docs":{}}},"docs":{},"f":{"docs":{},"f":{"0":{"0":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},"docs":{}},"docs":{}}}},"docs":{}},"1":{"5":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"docs":{},"f":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}},"docs":{}},"docs":{}},"docs":{}},"7":{"docs":{},"f":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"f":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{}}}}},"docs":{},"r":{"docs":{},"g":{"docs":{},"b":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"=":{"0":{"docs":{},"x":{"docs":{},"f":{"docs":{},"f":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}},"n":{"docs":{},"v":{"docs":{},"s":{"docs":{},"_":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"l":{"docs":{},"o":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"d":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"[":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"1":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"[":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"[":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"_":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}},"'":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},"'":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}}},"d":{"docs":{"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943}}}},"a":{"docs":{},"s":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}},"e":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}}}}},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},".":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":10.1},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":3.353516819571865},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.027848101265822784},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.04929577464788732},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.047021943573667714},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.021798365122615803},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.037267080745341616},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.015463917525773196}},".":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},"@":{"1":{"docs":{},".":{"0":{"docs":{},".":{"3":{"docs":{},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"docs":{}}},"docs":{}}},"docs":{}},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":10.007984031936127},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":5.0375},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":10.091836734693878},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},".":{"docs":{"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456}}},"'":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"(":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.03205128205128205},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":10.026954177897574},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0106951871657754},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":5.018518518518518},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":10.131578947368421}},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349}}},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}},")":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"_":{"docs":{},"x":{"docs":{},".":{"docs":{},"x":{"docs":{},".":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},"f":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},",":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}},".":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888}},"p":{"docs":{},"i":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}},":":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"'":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}},"r":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.014184397163120567},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":10.028571428571428},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.01871657754010695},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":5.037037037037037},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":10.131578947368421}},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}}}}}}}}}}}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"_":{"0":{"docs":{},".":{"0":{"docs":{},".":{"8":{"docs":{},".":{"docs":{},"d":{"docs":{},"f":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}},")":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}},"'":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}},"'":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}},"o":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},"[":{"docs":{},"g":{"docs":{},"p":{"docs":{},"s":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"[":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"e":{"docs":{},"d":{"docs":{},"g":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},")":{"docs":{},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"3":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.028169014084507043},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.022653721682847898},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.010126582278481013},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.03424657534246575},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.04285714285714286},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.015772870662460567},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.08571428571428572},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.022443890274314215}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"d":{"docs":{},"e":{"0":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}}}}}},".":{"docs":{},"g":{"docs":{},"o":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"3":{"0":{"0":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.04602510460251046},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"k":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}},"a":{"docs":{},"g":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.010126582278481013},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.019851116625310174},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},")":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}},":":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},".":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},",":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}}}},"e":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.028846153846153848},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00849673202614379},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"g":{"docs":{},"e":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"s":{"docs":{},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.008445945945945946}}},":":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}},"r":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"i":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/cli.html":{"ref":"advance/cli.html","tf":0.009187279151943463},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"s":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.03424657534246575},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"l":{"docs":{},"i":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}},"a":{"docs":{},"m":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"e":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0063604240282685515},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},".":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446}},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}}},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.016172506738544475},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.011811023622047244},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.017191977077363897},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.0273224043715847}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},"=":{"docs":{},"\"":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}},")":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"\"":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"i":{"docs":{},"v":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513}}}}},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}},"n":{"docs":{},"e":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}},"/":{"docs":{},"b":{"docs":{},"o":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}}},"l":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"i":{"docs":{},"r":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625}}}}}}}},"t":{"docs":{},"h":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"s":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},".":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889}}},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"u":{"docs":{},"s":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"e":{"docs":{},"r":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}},"t":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}},"a":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},"i":{"docs":{},"s":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"_":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"0":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"1":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"docs":{}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},"=":{"1":{"5":{"0":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}},"docs":{}},"docs":{}},"docs":{}},"i":{"docs":{},"c":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}},"a":{"docs":{},"g":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}},"a":{"docs":{},"p":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.015772870662460567},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.07142857142857142}},"s":{"docs":{},":":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}}}}}}}},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}}}}}}}},"n":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.01567398119122257},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.009719222462203024},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.11764705882352941},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}},"u":{"docs":{},"g":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"i":{"docs":{},"n":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.15},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.15},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.021798365122615803},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},":":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"/":{"docs":{},"u":{"docs":{},"n":{"docs":{},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"g":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}}}}}}}}}}}},"o":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"t":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012}},".":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"a":{"docs":{},"l":{"docs":{},";":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},":":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"v":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"x":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.009216589861751152},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.017543859649122806},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.017467248908296942},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.017777777777777778},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.07142857142857142}},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"e":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"e":{"docs":{},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}},",":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"!":{"docs":{},"!":{"docs":{},"!":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"r":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.02100840336134454},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.02054794520547945},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.019081272084805655},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.014962593516209476}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},")":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"a":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272}},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182}}},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"b":{"docs":{},"l":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},".":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}},"s":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"=":{"1":{"8":{"8":{"3":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"/":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}},":":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},"a":{"docs":{},"r":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.008445945945945946}}}}},"a":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811}}}},"docs":{}}}}}}},"l":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.03816793893129771},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"[":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"i":{"docs":{},"g":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.015873015873015872},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.013888888888888888},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.013368983957219251},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0125},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.008888888888888889},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.020080321285140562},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.013157894736842105},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":10.066225165562914},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.024324324324324326},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.02594810379241517},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.012958963282937365},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.02631578947368421},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.027586206896551724},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.026200873362445413},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.024},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.02666666666666667},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.04011461318051576},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.020958083832335328},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01092896174863388}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.013245033112582781},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}}}}}}},"(":{"docs":{},"[":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},".":{"docs":{},"g":{"1":{"6":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},".":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"(":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"r":{"docs":{},"q":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"[":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"e":{"docs":{},".":{"docs":{},"p":{"9":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},".":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},"docs":{}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"[":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}}}}}},")":{"docs":{},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"#":{"6":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},"docs":{}},"(":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"1":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{},"'":{"docs":{},"g":{"1":{"6":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"docs":{}},"4":{"docs":{},"'":{"docs":{},",":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}},"docs":{}},"p":{"1":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391}}}}},"2":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"docs":{}},"9":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"docs":{}}},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"[":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"1":{"6":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"9":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}}}}}}}}}}}}},"\"":{"docs":{},"g":{"7":{"docs":{},"\"":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},"docs":{}}}},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"=":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"1":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{},"'":{"docs":{},"p":{"1":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}}},"docs":{}},"docs":{}}}}}},"2":{"docs":{},"'":{"docs":{},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"9":{"docs":{},"'":{"docs":{},",":{"docs":{},"'":{"docs":{},"p":{"2":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{},"'":{"docs":{},"p":{"2":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"2":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},"'":{"docs":{},"p":{"2":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"docs":{}},"docs":{}}}}}},"2":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496}}}}},"docs":{}},"docs":{}}},"s":{"docs":{},"d":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"c":{"docs":{},"l":{"docs":{},"k":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"t":{"docs":{},"x":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}}},"_":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"=":{"docs":{},"'":{"docs":{},"p":{"1":{"2":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"6":{"docs":{},"'":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.020689655172413793},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.024},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.07894736842105263},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.07894736842105263},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.030612244897959183},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.038461538461538464},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.058823529411764705}},"s":{"docs":{},",":{"docs":{"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}}}}}}},"c":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}},"k":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}},"_":{"docs":{},"r":{"docs":{},"c":{"1":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},"docs":{}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"d":{"docs":{},")":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035}}}}},"e":{"docs":{},"c":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"r":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":5.016666666666667}},"(":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},",":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}},"u":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"t":{"docs":{},"i":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"c":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.017660044150110375},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.02005730659025788}},"=":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"s":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.026515151515151516},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":3.0386965376782076},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789}},"e":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"s":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"_":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"s":{"docs":{},"h":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"r":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}}},"/":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}},"/":{"docs":{},"p":{"docs":{},"c":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223}},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109}}}},"docs":{}}}}},"i":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"p":{"docs":{},"h":{"docs":{},"i":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}}}}}},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}},".":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}},"c":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},".":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"b":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}},"w":{"docs":{},"d":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},")":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"m":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":10.08130081300813},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},"(":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}}},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},".":{"docs":{},"d":{"docs":{},"u":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"3":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}},".":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}},"d":{"docs":{},"u":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"f":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.027586206896551724},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.026490066225165563},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0547945205479452},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.05263157894736842},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.05263157894736842},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.02564102564102564},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098}}}},"k":{"docs":{},"g":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.009925558312655087}},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}}}}}}}},"c":{"docs":{},"s":{"8":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"docs":{}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"1":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}},"s":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"o":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},".":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"r":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},"e":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.01904761904761905},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.015968063872255488},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02389705882352941},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.020080321285140562},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.022556390977443608},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.03792415169660679},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.019867549668874173},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.013108614232209739},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"i":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"e":{"docs":{},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},"s":{"docs":{},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}},":":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"_":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}},"/":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}}}}}}},"y":{"docs":{},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"c":{"docs":{},"h":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},":":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}},"l":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.01904761904761905},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"v":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577}}}}}},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}}}}},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.029556650246305417},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.02185792349726776},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.013779527559055118},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.020366598778004074},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.011235955056179775},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{},".":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},",":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}},"r":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}}}}}}}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}},"n":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334}}}}},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}},"[":{"1":{"docs":{},"]":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"docs":{}},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":5.090909090909091},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.026785714285714284},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":2.5546875},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":2.558333333333333},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01639344262295082}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}},"u":{"docs":{},"s":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.07894736842105263},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.02185792349726776},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"e":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"d":{"docs":{},")":{"docs":{},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}}}}}}}},"a":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.016736401673640166},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.034383954154727794},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.051470588235294115},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082}},"r":{"docs":{"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":5.052631578947368},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.014204545454545454},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}},"\"":{"docs":{},";":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}}}}}}},"i":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}},"=":{"0":{"docs":{},"x":{"0":{"1":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}},"=":{"1":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}},"e":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"docs":{},"[":{"2":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}},"docs":{}}}}}}}}}},"s":{"docs":{},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"o":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},")":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"9":{"1":{"5":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"docs":{}},"docs":{}},"docs":{}}},"e":{"docs":{},"u":{"8":{"6":{"8":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"u":{"docs":{},"l":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.017543859649122806},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.017467248908296942},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.017777777777777778},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"a":{"docs":{},"r":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.03968253968253968},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}},"e":{"docs":{},"x":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.047619047619047616}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}},"d":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"p":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}},"o":{"docs":{},"v":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}},"t":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.012867647058823529},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":6.002036659877801},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985}},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0169971671388102},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.017857142857142856},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.01749271137026239},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.014457831325301205},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.01904761904761905},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.027777777777777776},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0106951871657754},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0223463687150838},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.013333333333333334},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.005653710247349823}},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},";":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"\"":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"n":{"docs":{},"d":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.013257575757575758},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},":":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},":":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136}},"s":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}},".":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}},"t":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}},"o":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}}}}},"i":{"docs":{},"d":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},":":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}},"z":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"l":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"e":{"docs":{},"=":{"docs":{},"'":{"1":{"docs":{},".":{"1":{"7":{"docs":{},".":{"0":{"docs":{},".":{"docs":{},"b":{"1":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}},"docs":{}}}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}},"v":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}}},"i":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}},"p":{"docs":{},"l":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":10.054054054054054},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":5.021052631578947},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":10.005586592178771},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":3.371212121212121}},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"a":{"docs":{},"c":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"y":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}},"i":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}}},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.019867549668874173},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.045454545454545456}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}},"y":{"docs":{},".":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}},"r":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.012944983818770227},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.03333333333333333},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.03504043126684636},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.021956087824351298},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0275},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.028888888888888888},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.015037593984962405},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.027944111776447105},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.013994910941475827},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.02830188679245283},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.0759493670886076},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.052980132450331126},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00522875816993464},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.00997506234413965},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.015053763440860216},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.04},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.08888888888888889},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.14545454545454545},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.04878048780487805},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.06060606060606061},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.020599250936329586},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.014634146341463415},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.018461538461538463},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.030303030303030304}},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.014705882352941176}}}}}}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},",":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}},"r":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},"e":{"docs":{},"v":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01171875},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.07633587786259542}},"u":{"docs":{},"c":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"m":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}},"s":{"docs":{},"k":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"e":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.008595988538681949}}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}},"u":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.020833333333333332},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.025688073394495414},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.02278481012658228},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.021798365122615803},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.02586206896551724},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.005653710247349823},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}},":":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"/":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}},"e":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"l":{"docs":{},"e":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}},"t":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}},")":{"docs":{},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}},"s":{"docs":{},"/":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"c":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.027777777777777776},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":10.041420118343195},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.014634146341463415},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}},"t":{"docs":{},"p":{"docs":{},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},".":{"docs":{},"n":{"docs":{},"t":{"docs":{},"p":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"(":{"2":{"0":{"1":{"4":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"7":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}},"(":{"2":{"0":{"1":{"4":{"docs":{},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}}}},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"r":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}}}}}}}}}},"x":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"3":{"2":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}}}}}},"docs":{}},"docs":{}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"docs":{}}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"r":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}},"m":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"o":{"docs":{},"s":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"a":{"5":{"docs":{},")":{"docs":{},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"docs":{},"m":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.013377926421404682},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}},".":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}},"n":{"docs":{},"g":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"e":{"docs":{},"(":{"0":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"x":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}},"1":{"0":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}}},"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"2":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"3":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666}}}}},"8":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01}}}}},"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},",":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}}}},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.053763440860215055},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"l":{"docs":{},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"w":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.013725490196078431},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"d":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"i":{"docs":{},"o":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.11235955056179775},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409}},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"a":{"docs":{},"n":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"t":{"docs":{},"e":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00718954248366013}},":":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"'":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"i":{"docs":{},"o":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"r":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"x":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222}},"=":{"2":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629}},"=":{"1":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}}}}}}}}}}}}}}},"q":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"=":{"1":{"2":{"8":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}},"d":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}}}},":":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"/":{"docs":{},"t":{"docs":{},"x":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"g":{"docs":{},"b":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":5.042253521126761},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"_":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}},"c":{"1":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"docs":{},"z":{"1":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282}}},"2":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}},"3":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}},"4":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}},"=":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"r":{"docs":{},"c":{"docs":{},"z":{"1":{"docs":{},")":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616}},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645}},".":{"docs":{},"e":{"docs":{},"u":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},"l":{"docs":{},"l":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035}},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}},")":{"docs":{},")":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}},"e":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"o":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"m":{"0":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0125}},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"b":{"docs":{},"o":{"docs":{},"t":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}},"w":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},"f":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"i":{"docs":{},"d":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408}},"/":{"docs":{},"n":{"docs":{},"f":{"docs":{},"c":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612}}}}}}}}},"s":{"docs":{},"t":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"a":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"\"":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}},"_":{"docs":{},"b":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"m":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":10.058712121212121},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":13.026476578411405}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"=":{"4":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576}}}},"docs":{}}}}}}}}}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222}},")":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"g":{"docs":{},"p":{"docs":{},"i":{"docs":{},"o":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"p":{"2":{"0":{"docs":{},"\"":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}},"docs":{}},"docs":{}}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"=":{"1":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"=":{"5":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"d":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"_":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"2":{"4":{"8":{"3":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":5.033707865168539}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}}}},"s":{"1":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.007481296758104738},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"e":{"docs":{},"c":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.041666666666666664},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},",":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0457516339869281},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0220125786163522},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.014634146341463415},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"l":{"docs":{},"i":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"y":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}},"s":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708}}},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}},"u":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.022443890274314215}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}},":":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":5.002493765586035}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"=":{"docs":{},"o":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.02493765586034913}}}}},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"=":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.007339449541284404},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.018292682926829267},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.02005730659025788},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.014084507042253521},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":10.043478260869565},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.013368983957219251},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.0898876404494382},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.008888888888888889},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02857142857142857},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.02869757174392936},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.023668639053254437},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.015723270440251572},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.011811023622047244},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.018518518518518517},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.013725490196078431},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.008728179551122194},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.02591792656587473},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.009363295880149813},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.012195121951219513},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.015463917525773196},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}},"u":{"docs":{},"p":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":5.03125},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}},":":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},"!":{"docs":{},"!":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":10.007633587786259},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.041237113402061855},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.03278688524590164},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},"*":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"i":{"docs":{},"n":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}},"f":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}},"i":{"2":{"docs":{},"c":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}}},"docs":{},"p":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"d":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}}}}}}},"i":{"docs":{},"n":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.01904761904761905}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}}}}}},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"m":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"_":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}},"s":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943}},"s":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}},"n":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"=":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"&":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"=":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"&":{"docs":{},"i":{"docs":{},"d":{"docs":{},"x":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"i":{"docs":{},"d":{"docs":{},"x":{"docs":{},"+":{"docs":{},"\"":{"docs":{},"&":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"&":{"docs":{},"v":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"=":{"0":{"docs":{},"&":{"docs":{},"v":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"+":{"docs":{},"\"":{"docs":{},"&":{"docs":{},"v":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"l":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"r":{"docs":{},"v":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.018292682926829267},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.012004801920768308},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":10.094827586206897},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.02631578947368421},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}},".":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"'":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}},"_":{"docs":{},"i":{"docs":{},"p":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"*":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"=":{"docs":{},"(":{"docs":{},"'":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"3":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}},"[":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"=":{"docs":{},"(":{"docs":{},"'":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.01272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.02830188679245283},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.05063291139240506},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.043859649122807015},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}}}}},"(":{"docs":{},"'":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}},"o":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}},"s":{"docs":{},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}}},"​":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"=":{"docs":{},"b":{"docs":{},"'":{"1":{"2":{"3":{"4":{"5":{"6":{"7":{"8":{"9":{"0":{"1":{"2":{"3":{"4":{"5":{"6":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},"i":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"a":{"docs":{},"l":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":3.371148459383753},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.02464788732394366},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.025078369905956112},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.015463917525773196},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506}}}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},".":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}}},"=":{"docs":{},"p":{"docs":{},"y":{"3":{"4":{"3":{"4":{"3":{"4":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872}},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"g":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}},"t":{"docs":{"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549}}}},"e":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"n":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}}},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"n":{"docs":{},"s":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.040740740740740744},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.016172506738544475},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.023809523809523808},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":5.013333333333334},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"s":{"docs":{},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},":":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}}},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}}}},"d":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.024630541871921183},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.02185792349726776},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.00984251968503937},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.017456359102244388},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"s":{"docs":{},"m":{"docs":{},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"p":{"docs":{},"h":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}}}},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":10.022727272727273}}}},"t":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}}}}}}},"m":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}},"p":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}},"a":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}}}}}}}},"c":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.04017857142857143},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}},"a":{"docs":{},"n":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0273972602739726}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"g":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422}},"_":{"docs":{},"s":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}}}}},"i":{"7":{"0":{"0":{"6":{"docs":{},"a":{"2":{"0":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825}},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"i":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},"e":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}},".":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{"products.html":{"ref":"products.html","tf":0.02},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":10.163179916317992},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":5.0625},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":10.058603491271821},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":3.4681647940074902},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.11290322580645161},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.13934426229508196},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},")":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476}}}},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}}}}}}}},"f":{"docs":{},"s":{"docs":{},"k":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}}}}}}}}}}}}}}}}}},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}},"s":{"docs":{},"k":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"[":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"z":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}},"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}},"3":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}},"4":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"n":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273}},"a":{"docs":{},"l":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.017045454545454544},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.02694610778443114}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"s":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"'":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}},"e":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759}}}}}}}},"p":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":10.03206997084548},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":10.044444444444444},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}}},"y":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},".":{"docs":{"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428}}},":":{"docs":{"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},"m":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.05555555555555555},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},".":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735}}},"p":{"docs":{},"l":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"i":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"f":{"docs":{},"i":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}},"u":{"docs":{},"l":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},"d":{"docs":{},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"s":{"docs":{},".":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}},".":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},")":{"docs":{"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"z":{"docs":{},"e":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.01240694789081886},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.012307692307692308}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"=":{"0":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"docs":{}},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"/":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}},"a":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"e":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.014545454545454545}}},"w":{"docs":{},"a":{"docs":{},"v":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}},"t":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},"a":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.009398496240601503},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.008905852417302799},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":3.3787878787878785},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806}}},":":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},"!":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236}}},"=":{"0":{"docs":{},"x":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}}},"docs":{}}}}}}}}}}}}},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}},"=":{"docs":{},"r":{"docs":{},"m":{"docs":{},"t":{"docs":{},".":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}}}}},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"b":{"docs":{},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"t":{"docs":{},"e":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00522875816993464},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"(":{"2":{"docs":{},")":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"docs":{}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}},"i":{"docs":{},"c":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516}},"s":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"docs":{}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883}}},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.02054794520547945},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.04285714285714286},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}}},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}},"c":{"docs":{},"k":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.015384615384615385}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}},"y":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}},"r":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"a":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}},",":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.02759526938239159},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},":":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"\"":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655}}}}}},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},">":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}},"n":{"docs":{},"g":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.06060606060606061},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.023809523809523808}}}}}},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.022900763358778626},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634}}},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"]":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},"]":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}},"i":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"e":{"docs":{},"p":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.03164556962025317},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.045454545454545456},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.028846153846153848},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.015463917525773196},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.014970059880239521}},"s":{"docs":{},":":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},":":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}},"f":{"docs":{},"a":{"docs":{},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":3.3490073145245556},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"c":{"docs":{},"k":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},",":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}}}},":":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}},"a":{"docs":{},"g":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}},"p":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},".":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}}}}}}},"=":{"1":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.04878048780487805},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}}}}},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}}},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334}}},",":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.06666666666666667},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.023809523809523808},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}},"e":{"docs":{},"r":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}},"s":{"docs":{},"s":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"y":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},",":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"!":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"'":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}}}}}}}},"h":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"i":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"e":{"docs":{},".":{"docs":{"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}}}}}}},"b":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"r":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}},"p":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"i":{"docs":{},"b":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"e":{"docs":{},"t":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.02054794520547945},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872}}},"q":{"docs":{},"u":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"y":{"docs":{},"p":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213}},")":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"m":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"n":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"o":{"docs":{},",":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"f":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.01675977653631285},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":10.012048192771084},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":5.03125},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"documents/license.html":{"ref":"documents/license.html","tf":0.04580152671755725}},"e":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}},"h":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}}}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}},":":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303}}},"c":{"docs":{},"k":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"e":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.024630541871921183},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.0273224043715847},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.009150326797385621},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.02369077306733167},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.06741573033707865},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0390625}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0149812734082397}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"f":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.007481296758104738}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}}}}},"_":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.007481296758104738}}}}}},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}}}}}}}}}}},"_":{"docs":{},"d":{"docs":{},"r":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}},"r":{"docs":{},"x":{"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"e":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}}},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"t":{"docs":{},"x":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}},"l":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}},"t":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"f":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"[":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"'":{"docs":{},"r":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},":":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}}},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"docs":{}}},"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.017721518987341773}}},"!":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}},".":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}},":":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},":":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}},"=":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"r":{"docs":{},"c":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"r":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},".":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.023321554770318022}},"n":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}}}}}}},"r":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},".":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}},"e":{"docs":{},"r":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}}},"c":{"docs":{},"k":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"a":{"1":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323}}},"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826}},"r":{"docs":{},"e":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136}}}}},"p":{"docs":{},"e":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"l":{"docs":{},"l":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}}},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/":{"ref":"datasheets/boards/","tf":3.3888888888888884},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":3.411764705882353},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},".":{"docs":{"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555}}}},"\"":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}},".":{"docs":{"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},",":{"docs":{"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}}}}},"l":{"docs":{},"l":{"docs":{},".":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"p":{"docs":{},"l":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},"e":{"docs":{},".":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}}}},"f":{"docs":{},"e":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":5.013888888888889},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"w":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735}}},"e":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}},".":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419}}},":":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.007339449541284404},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":3.371212121212121},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}},"a":{"docs":{},"n":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.03515625},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.011450381679389313},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"l":{"docs":{},"e":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"a":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.017082785808147174}}},"b":{"docs":{},"l":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}},"h":{"docs":{},"m":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}},"a":{"docs":{},"t":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098}}}}}}},"l":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}},"=":{"docs":{},"'":{"docs":{},"p":{"2":{"1":{"docs":{},"'":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"docs":{}},"docs":{}}}},")":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"k":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"k":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":10.03475935828877},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.017543859649122806},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.017467248908296942},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.017777777777777778},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":3.4705882352941173},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":3.356255969436485},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915}}},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},"_":{"docs":{},"u":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}},"s":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}},"4":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"2":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"8":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"docs":{}},"6":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"m":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"s":{"docs":{},"(":{"2":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"(":{"5":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{}}}}},"o":{"docs":{},"w":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}},"t":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}},".":{"docs":{"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}}},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.014705882352941176},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.03759398496240601},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"=":{"0":{"docs":{},"x":{"0":{"docs":{},"a":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.014705882352941176}}}},"docs":{}}},"docs":{}}}}}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}}}}}}}},"m":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"a":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603}},"l":{"docs":{},"l":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"r":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}},"r":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}},"c":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}},"s":{"docs":{},".":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"s":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}},"i":{"docs":{},"d":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}},"g":{"docs":{},"p":{"docs":{},"i":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146}}}}}},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"=":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"'":{"docs":{},"w":{"docs":{},"i":{"docs":{},"p":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"d":{"docs":{},".":{"docs":{},"b":{"docs":{},"l":{"docs":{},"y":{"docs":{},"n":{"docs":{},"k":{"docs":{},".":{"docs":{},"c":{"docs":{},"c":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}}}},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.05555555555555555},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.03125}},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"_":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517}}}},"s":{"docs":{},")":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},",":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}},":":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}},"e":{"docs":{},"a":{"docs":{},"y":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"f":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.09523809523809523},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01092896174863388},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"i":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.02443609022556391},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.015384615384615385},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.018633540372670808},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01092896174863388},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},".":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"m":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"e":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/cli.html":{"ref":"advance/cli.html","tf":0.005653710247349823}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"w":{"docs":{},"n":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666}}}},"n":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811}}}}}},"i":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":10.054054054054054},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},",":{"docs":{"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}},"(":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109}}}},"docs":{}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}}}},"l":{"docs":{},"s":{"docs":{},"b":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}}}}}},"s":{"docs":{},"b":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{},"n":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"[":{"0":{"docs":{},"x":{"0":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"[":{"0":{"docs":{},"x":{"0":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"x":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"k":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}}}},"y":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":10.003154574132493}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":10.005464480874316}},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"c":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}},"'":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}},"\"":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}},";":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"docs":{}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"v":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"s":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}},"i":{"docs":{},"n":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}}}}},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.014038876889848811},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":10.089655172413794},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},"a":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},"=":{"docs":{},"'":{"docs":{},"p":{"2":{"2":{"docs":{},"'":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"docs":{}},"docs":{}}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"(":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"docs":{}}}}}}}}}}},"n":{"6":{"5":{"docs":{},"h":{"docs":{},"v":{"docs":{},"d":{"2":{"3":{"0":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{},"i":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},":":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}},"f":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"i":{"docs":{},"p":{"docs":{},",":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"b":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"[":{"0":{"docs":{},"x":{"0":{"1":{"docs":{},",":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"4":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{}},"docs":{}}},"1":{"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}}},"docs":{}}}}}}}},"'":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"'":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943}}}}}}}},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}}}}}}}},"t":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.011221945137157107}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"5":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"docs":{}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"1":{"2":{"8":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"3":{"2":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}},"6":{"4":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}},"docs":{}},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"1":{"2":{"8":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"docs":{}}}}}}},"f":{"7":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}},"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"=":{"1":{"2":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"7":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"r":{"docs":{},"x":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"t":{"docs":{},"x":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"q":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577}},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"/":{"docs":{},"s":{"docs":{},"d":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"docs":{}}}}},"n":{"docs":{},"b":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"docs":{}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},",":{"docs":{},"'":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},"r":{"docs":{},"v":{"1":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"(":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"docs":{},"b":{"docs":{},"'":{"docs":{},"a":{"docs":{},"b":{"3":{"4":{"5":{"6":{"7":{"8":{"9":{"0":{"1":{"2":{"3":{"4":{"5":{"6":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}},"t":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}},"e":{"docs":{},"e":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552}}}}}}},"a":{"docs":{},"d":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":10.083333333333334},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.05846153846153846},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"i":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"_":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":5.01432664756447},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.018633540372670808}},"s":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"'":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"r":{"docs":{},"d":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.05714285714285714}}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"'":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"'":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}},"!":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"m":{"docs":{},",":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}},".":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}},"“":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"'":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}},"u":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.04819277108433735},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0196078431372549},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},"/":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":10.002724795640328}}}}}}}}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}},"k":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}},"g":{"docs":{},"l":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}},":":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"p":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}},"i":{"docs":{},"c":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}},"s":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"t":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}}}}}}},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}},".":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}}}}},"n":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143}}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.06382978723404255},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.05555555555555555},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.020689655172413793},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.024},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},",":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888}}}},".":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}},"p":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.011111111111111112},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"e":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},":":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"r":{"docs":{},"n":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"a":{"docs":{},"b":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"l":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513}}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},";":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}},"k":{"docs":{},"e":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.03508771929824561},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"n":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"i":{"docs":{},"l":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"r":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},":":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"=":{"docs":{},"[":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"|":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"]":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}}}}}}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"[":{"docs":{},".":{"docs":{},"g":{"docs":{},"z":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"l":{"docs":{},"k":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},"e":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"s":{"docs":{},"k":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01818181818181818}}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.02127659574468085},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.03773584905660377},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.03902439024390244},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"5":{"0":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}},"docs":{}},"docs":{}},"1":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"2":{"5":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099}}}},"docs":{}},"5":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}}},"docs":{}}},"1":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}},".":{"2":{"5":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"docs":{}},"5":{"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"docs":{}}},"2":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}},".":{"5":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"4":{"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}},"5":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886}}}},"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}}}}}}}}}}}}},".":{"5":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}},"docs":{}}},"_":{"docs":{},"u":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}},"m":{"docs":{},"s":{"docs":{},"(":{"1":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}}}},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.034482758620689655},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.034482758620689655},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.012958963282937365},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232}},"=":{"0":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}},"1":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"docs":{}},"5":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"docs":{}},"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},"s":{"docs":{},"=":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{}}}}}}},"m":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},")":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"r":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":10.019607843137255},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":10.022012578616351},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},".":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.00975609756097561}}},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"p":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}},"c":{"docs":{},"k":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"e":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"s":{"docs":{},"_":{"docs":{},"*":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"c":{"docs":{},"p":{"docs":{},"u":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"m":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}},"l":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"n":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}},"e":{"docs":{},"l":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":5.052631578947368},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"x":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419}},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},":":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"/":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"y":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}},"s":{"docs":{},".":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},":":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"m":{"docs":{},"p":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.012944983818770227},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0215633423180593},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"e":{"docs":{},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"l":{"docs":{},"s":{"docs":{},"b":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"i":{"docs":{},"c":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}},"r":{"docs":{},"i":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}},"c":{"docs":{},"k":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},",":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.011037527593818985},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.02865329512893983}},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},"=":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"x":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},".":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.00755939524838013}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"t":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"c":{"docs":{},"e":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.022058823529411766}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"s":{"docs":{},"h":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}},"u":{"docs":{},"e":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"/":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},":":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01171875},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.018633540372670808},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282}}},"]":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}}}}},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},"a":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":5.00253164556962},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}},"w":{"docs":{},"o":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"'":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"x":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"t":{"docs":{},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}},"_":{"docs":{},"i":{"docs":{},"q":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"docs":{},"r":{"docs":{},"m":{"docs":{},"t":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222}},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"y":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"p":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"=":{"1":{"4":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"docs":{}},"docs":{}}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},"e":{"docs":{},"s":{"docs":{},"=":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}},":":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}},"d":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"/":{"docs":{},"r":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"y":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}},"p":{"docs":{},"e":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.02459016393442623},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"d":{"docs":{},".":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},":":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}},"t":{"docs":{},"y":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}}},"n":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},"l":{"docs":{},"s":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}},"l":{"docs":{},"s":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"c":{"docs":{},"p":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415}},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}},"z":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},"]":{"docs":{},"]":{"docs":{},"]":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}}}},"v":{"0":{"docs":{},".":{"9":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}}},"1":{"docs":{},".":{"0":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"1":{"8":{"docs":{},".":{"1":{"docs":{},".":{"docs":{},"r":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"docs":{}}}},"docs":{}}},"docs":{}},"4":{"docs":{},".":{"6":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"docs":{}}},"docs":{}},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164}}}},"2":{"docs":{},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164}}},".":{"0":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"docs":{}}},"3":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},".":{"0":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"docs":{}}},"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}},"o":{"docs":{},"u":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.012944983818770227},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},",":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},")":{"docs":{},".":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}},"l":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"u":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.01904761904761905},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0215633423180593},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.00998003992015968},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.015555555555555555},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.0321285140562249},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02857142857142857},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.019867549668874173},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.032520325203252036},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.015748031496062992},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.06622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.04},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.01437908496732026},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.011221945137157107},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.02159827213822894},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.02102496714848883},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.022082018927444796},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.014545454545454545},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.016853932584269662},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.040983606557377046},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.012307692307692308},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.030054644808743168},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},")":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}}},"=":{"1":{"docs":{},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"2":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}},"docs":{}},"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"docs":{}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},":":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.011976047904191617},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.02459016393442623}}},":":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446}}}}}}}}},"i":{"docs":{},"d":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.030379746835443037},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.01800720288115246},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.011879049676025918},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.026143790849673203},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},";":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"s":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"=":{"docs":{},"'":{"docs":{},"v":{"1":{"docs":{},".":{"8":{"docs":{},".":{"6":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},"docs":{}}},"docs":{}}},"docs":{}}}},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"a":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"i":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"f":{"docs":{"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}},"i":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.013377926421404682},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"e":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"r":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}}},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}},"e":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},")":{"docs":{},":":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}},"i":{"docs":{},"a":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.02464788732394366},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.018808777429467086},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},",":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}},":":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}},"e":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525}}}}}},"t":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":3.3490073145245556},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"i":{"docs":{},"s":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":3.3423153692614767}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}}}}}}},"e":{"docs":{},"w":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}},"c":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"d":{"docs":{},":":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"4":{"docs":{},"d":{"8":{"docs":{},":":{"docs":{},"f":{"0":{"1":{"3":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}},"s":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":3.340909090909091}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543}},".":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}}}}}},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.03571428571428571},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872}},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},".":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}}}}},"d":{"docs":{},"a":{"docs":{},"f":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}},"d":{"docs":{},"d":{"docs":{},"/":{"2":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"docs":{}}}},"p":{"docs":{},"p":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}},",":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"w":{"0":{"1":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":10.140350877192983},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.03816793893129771}},",":{"docs":{"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666}}},":":{"docs":{"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806}}}},"docs":{}},"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},"_":{"docs":{},"p":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}},"l":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"'":{"docs":{},"v":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"r":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"b":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}},"e":{"docs":{},".":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}},"e":{"docs":{},"k":{"docs":{},",":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}},"l":{"docs":{},"i":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"i":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023}},"f":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.015789473684210527},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.012962962962962963},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.027586206896551724},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.032},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.027586206896551724},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.026490066225165563},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.007067137809187279}},"/":{"docs":{},"b":{"docs":{},"t":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}}}}}}}},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}}},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"w":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}},"(":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"_":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":10.041269841269841},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":5.017543859649122},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":5.020689655172414},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.05343511450381679}}},"y":{"2":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.02631578947368421}},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015}}},":":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015}}}},"3":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.04827586206896552}},",":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}},":":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}},"docs":{},",":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}},".":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},":":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}},"r":{"docs":{},"e":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}}}}}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.037267080745341616},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":2.546153846153846},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"s":{"docs":{},",":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"x":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},";":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},":":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/license.html":{"ref":"documents/license.html","tf":0.022900763358778626}}}}},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"s":{"docs":{},"h":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0196078431372549}}}},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"e":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.02694610778443114}},"'":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"s":{"docs":{},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}},"z":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},",":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}}}}}}},"a":{"docs":{},"y":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"s":{"docs":{},";":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},",":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"r":{"docs":{},"n":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}}}}}},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}},"l":{"docs":{},"k":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"i":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.01904761904761905},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.009925558312655087},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.030534351145038167},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}}}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}}}}}}}},"v":{"docs":{},"e":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}},"k":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.013333333333333334},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.025787965616045846}},"_":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"_":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}}}}}}}}},"s":{"docs":{},"[":{"docs":{},"'":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"'":{"docs":{},"]":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0213903743315508},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667}},".":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789}}}}}}},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"c":{"docs":{},"h":{"docs":{},"d":{"docs":{},"o":{"docs":{},"g":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436}}}}}}}}},"l":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}},"a":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":10.039170506912443},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":10.022222222222222},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"(":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"(":{"docs":{},"[":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"[":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"m":{"docs":{},"y":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"docs":{},"'":{"docs":{},"m":{"docs":{},"y":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"\"":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"[":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"=":{"docs":{},"(":{"docs":{},"'":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"0":{"docs":{},".":{"1":{"0":{"7":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},"docs":{}},"docs":{}},"4":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},"docs":{}}},"1":{"7":{"8":{"docs":{},".":{"1":{"0":{"7":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"docs":{}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},"a":{"docs":{},"p":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"[":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"[":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},"_":{"docs":{},"a":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"_":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556}}}}},"p":{"docs":{},"a":{"2":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"_":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556}}}}}}},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}},",":{"docs":{"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},".":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"=":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"[":{"docs":{},"'":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"'":{"docs":{},"]":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}},"a":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"d":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}},"'":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"b":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"e":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02022058823529412},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.009398496240601503},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0063604240282685515}},"_":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}},"u":{"docs":{},"f":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}},"=":{"0":{"docs":{},"x":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{}},"docs":{}}},"docs":{}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}}}}}}},"a":{"docs":{},"p":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}}},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}},"t":{"docs":{},"e":{"docs":{"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549}}}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"s":{"docs":{},"e":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}},"u":{"docs":{},"p":{"docs":{},"a":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"p":{"docs":{},"a":{"2":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"docs":{}}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}},"d":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":10.091954022988507},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.012958963282937365}},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"=":{"2":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}}}}}}}}}}}}}},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"s":{"2":{"8":{"1":{"2":{"docs":{},"b":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}}}},"y":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"'":{"docs":{},"v":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}}},"l":{"docs":{},"l":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"'":{"docs":{},"r":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"v":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},"l":{"docs":{},"l":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},"?":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"t":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}}}}},"u":{"docs":{},"m":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"a":{"docs":{},"w":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}}}},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091}}},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273}}},"/":{"docs":{},"x":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"#":{"0":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.016181229773462782},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.02556818181818182},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.053475935828877004},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.018433179723502304},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.02734375},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.02702702702702703},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.026785714285714284},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0175},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.07042253521126761},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.021608643457382955},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.04924242424242424},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.07801418439716312},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.08374384236453201},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.08743169398907104},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.04962779156327544},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.09433962264150944},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.022321428571428572},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.016483516483516484},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.037037037037037035},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02857142857142857},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.041353383458646614},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.023668639053254437},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.02702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.027944111776447105},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.017716535433070866},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.014256619144602852},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.012962962962962963},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.05172413793103448},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.011450381679389313},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.02830188679245283},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.03137254901960784},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.03366583541147132},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.028077753779697623},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.015772870662460567},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01912568306010929},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.06060606060606061},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.012468827930174564}},"#":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},"#":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}},"#":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"{":{"docs":{},"}":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}},"!":{"docs":{},"/":{"docs":{},"u":{"docs":{},"s":{"docs":{},"r":{"docs":{},"/":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"/":{"docs":{},"e":{"docs":{},"n":{"docs":{},"v":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}}}},")":{"docs":{},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"(":{"0":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},"x":{"0":{"2":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"4":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"1":{"docs":{},"a":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"2":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{},"f":{"0":{"1":{"3":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"4":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"docs":{}},"docs":{}},"docs":{}}},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"0":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"docs":{}}},"1":{"0":{"0":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{},".":{"1":{"1":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}},"docs":{}},"docs":{}}},"6":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},".":{"1":{"9":{"docs":{},".":{"0":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"docs":{}}},"docs":{}},"docs":{}},",":{"0":{"docs":{},",":{"1":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},",":{"0":{"docs":{},",":{"1":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"1":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}}},"1":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"2":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"docs":{}},"3":{"docs":{},")":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}},"docs":{},"g":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"*":{"docs":{},"*":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"3":{"0":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},"docs":{}},"docs":{}},"docs":{}},"2":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"4":{"0":{"0":{"docs":{},",":{"2":{"0":{"0":{"docs":{},",":{"1":{"0":{"0":{"docs":{},",":{"3":{"0":{"0":{"docs":{},",":{"2":{"0":{"0":{"docs":{},",":{"4":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"k":{"docs":{},"i":{"docs":{},"b":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"8":{"0":{"0":{"0":{"docs":{},",":{"1":{"1":{"0":{"0":{"0":{"docs":{},",":{"8":{"0":{"0":{"0":{"docs":{},",":{"1":{"1":{"0":{"0":{"0":{"docs":{},",":{"6":{"0":{"0":{"0":{"docs":{},",":{"1":{"3":{"0":{"0":{"0":{"docs":{},",":{"6":{"0":{"0":{"0":{"docs":{},",":{"3":{"0":{"0":{"0":{"docs":{},",":{"8":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"6":{"8":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}},"docs":{}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}},"s":{"docs":{},"e":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"r":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":3.337535014005602}}}}}},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"_":{"docs":{},"h":{"docs":{},"z":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}}},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}}}}}}}}},"l":{"0":{"1":{"docs":{},",":{"docs":{"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}},"docs":{}},"7":{"6":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},"docs":{}},"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525}}}}},"r":{"docs":{},"a":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"w":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}},"p":{"docs":{},"y":{"4":{"docs":{},",":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}},"docs":{},",":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}},"i":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},"i":{"docs":{},"s":{"2":{"docs":{},"h":{"docs":{},"h":{"1":{"2":{"docs":{},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}}}},"docs":{}},"k":{"docs":{},"e":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"t":{"docs":{},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"e":{"docs":{},"n":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"p":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"a":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"/":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}}}}}},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"r":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634}}},"b":{"docs":{},"j":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}},"p":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"1":{"0":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},"=":{"docs":{},"s":{"docs":{},"d":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}}}}},"2":{"docs":{},")":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}},"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},")":{"docs":{},",":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}}},"a":{"docs":{},")":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}},"c":{"docs":{},"k":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}},"i":{"docs":{},"c":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}},"n":{"docs":{},"#":{"6":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},"docs":{}},"=":{"docs":{},"'":{"docs":{},"p":{"1":{"2":{"docs":{},"'":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"docs":{}},"docs":{}}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}}},"e":{"docs":{},".":{"docs":{},"g":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},",":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}},"r":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"u":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"g":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}}},"m":{"docs":{},"e":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},"c":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},"e":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}},"o":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"_":{"docs":{},"*":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"c":{"docs":{},"l":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112}}}}}},"d":{"docs":{},"a":{"docs":{},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}}}},"i":{"7":{"0":{"0":{"6":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}},"a":{"2":{"0":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}},"y":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"=":{"docs":{},"'":{"docs":{},"g":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"p":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}}},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"q":{"2":{"4":{"0":{"4":{"0":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"6":{"4":{"docs":{},")":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{}},"docs":{}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"a":{"docs":{},"d":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"p":{"docs":{},"l":{"docs":{},")":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}},"c":{"docs":{},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},")":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629}}}}}}}}}}}},"g":{"docs":{},"b":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},"_":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}}},"a":{"docs":{},"w":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":2.50709219858156}}}},"t":{"docs":{},"r":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}},"c":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"x":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}},"b":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"'":{"1":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"1":{"4":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"docs":{}},"docs":{}},"8":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{},"w":{"docs":{},"i":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},"c":{"docs":{},")":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238}}}}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},":":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},")":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"v":{"docs":{},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"o":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"z":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"f":{"0":{"1":{"3":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"4":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"docs":{}},"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"docs":{},"e":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"f":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}},"n":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}},"p":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},"v":{"4":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"docs":{}}},"t":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"'":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"=":{"0":{"docs":{},"x":{"0":{"1":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"v":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}},"t":{"docs":{},")":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"f":{"docs":{},"r":{"docs":{},"c":{"6":{"3":{"0":{"0":{"2":{"docs":{},"h":{"docs":{},"n":{"docs":{},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}}}},"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{},"_":{"docs":{},"m":{"docs":{},"f":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"_":{"docs":{},"a":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}},"p":{"docs":{},"l":{"3":{"1":{"1":{"5":{"docs":{},"a":{"2":{"docs":{},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}},"c":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"y":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"j":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}},"n":{"docs":{},"i":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"k":{"docs":{},"e":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}},"x":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}}}}},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"o":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.022222222222222223}},"e":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},":":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943}}}}}}},"f":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"i":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}},"a":{"docs":{},"t":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"t":{"docs":{},"n":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},"e":{"docs":{},"l":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}},"m":{"docs":{},"p":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},")":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"z":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}},"x":{"1":{"docs":{},"/":{"docs":{},"r":{"docs":{},"x":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}}}},"docs":{}}}}},"docs":{},"d":{"docs":{},"/":{"docs":{},"r":{"docs":{},"x":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"a":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"p":{"docs":{},")":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},"p":{"docs":{},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"l":{"docs":{},"e":{"docs":{},"'":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},"m":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},"b":{"docs":{},"p":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"q":{"docs":{},"a":{"docs":{},")":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}},"t":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"m":{"docs":{},"a":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}},"l":{"docs":{},"s":{"docs":{},"o":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}},"l":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}},"e":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422}}},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}},"u":{"docs":{},"r":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182}}}},"n":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}},"d":{"docs":{},"c":{"docs":{},")":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"n":{"docs":{},"g":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}},"k":{"docs":{},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}}}},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}}}},"r":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}},"s":{"docs":{},"v":{"docs":{},")":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}},")":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}},"e":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}},"~":{"0":{"docs":{},".":{"4":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},"8":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},"docs":{}}},"1":{"docs":{},"u":{"docs":{},"a":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}},".":{"5":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},"docs":{}}},"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},"g":{"docs":{},")":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"a":{"docs":{},"p":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}}}},"%":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}},"*":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"docs":{}}}}}}},"l":{"docs":{},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"[":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}},"~":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"e":{"docs":{},"p":{"docs":{},"y":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"v":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"i":{"docs":{},"a":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"`":{"docs":{},"`":{"docs":{},"p":{"1":{"0":{"docs":{},"`":{"docs":{},"`":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"9":{"docs":{},"`":{"docs":{},"`":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"docs":{}},"2":{"0":{"docs":{},"`":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"docs":{}},"3":{"docs":{},"`":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}},"docs":{}}}},">":{"docs":{},"=":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}},"\"":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}},"{":{"docs":{},"m":{"docs":{},",":{"docs":{},"n":{"docs":{},"}":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}},"x":{"8":{"6":{"docs":{},")":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}},"c":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.02027027027027027},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"a":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"b":{"docs":{},"l":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"e":{"docs":{},"/":{"docs":{},"w":{"docs":{},"i":{"docs":{},"r":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}},"s":{"docs":{},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},".":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}},"s":{"docs":{},"e":{"docs":{"products.html":{"ref":"products.html","tf":0.02},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0058823529411764705},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"t":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.014457831325301205},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.05},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":5.021978021978022},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},"m":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}}},"docs":{}},"e":{"docs":{},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"s":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}},"r":{"docs":{},"d":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.011879049676025918},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.05517241379310345},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},")":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},"'":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"e":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},":":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}},"r":{"docs":{},"i":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.03333333333333333},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}},"'":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"_":{"docs":{},"d":{"docs":{},"u":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"_":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}},"'":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"(":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}}}}}}}}}}}}},"x":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"f":{"docs":{},"o":{"docs":{},"_":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"=":{"0":{"docs":{},"x":{"0":{"0":{"2":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"1":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{}}},"1":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}}}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},"(":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"o":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}},"o":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.017142857142857144},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.021505376344086023}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},":":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.0625},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.012195121951219513}}}}}}}},"p":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}},"i":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655}}}}}},"_":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"s":{"docs":{},"=":{"docs":{},"'":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},")":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}},"m":{"docs":{},"e":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"e":{"docs":{"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.07633587786259542}},"r":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"i":{"docs":{},"f":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.013513513513513514},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"documents/certificates.html":{"ref":"documents/certificates.html","tf":10.213740458015268}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"s":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}},"p":{"docs":{},"d":{"docs":{},"f":{"docs":{},")":{"docs":{"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.007633587786259542}}}}}}},"\"":{"docs":{"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.007633587786259542}}}}}}}},"l":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"e":{"docs":{},"=":{"docs":{},"'":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"t":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"s":{"docs":{},"=":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":10.041666666666666},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.05},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409}}}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"a":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"o":{"docs":{},"m":{"1":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},"4":{"docs":{},")":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815}}}},"6":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.01680672268907563},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"i":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"u":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}},";":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}},"r":{"docs":{},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}},"e":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},"d":{"docs":{},"!":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"x":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"i":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.023809523809523808},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},"o":{"docs":{},"n":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}}}}},"s":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},"m":{"docs":{},"u":{"docs":{},"n":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}},"a":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.010752688172043012},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.011307420494699646},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},":":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},":":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},")":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"o":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"l":{"docs":{},"i":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},";":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}}}}}}},"n":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.04430379746835443},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.0625},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.025495750708215296},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.02976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.026239067055393587},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.03459119496855346},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.033734939759036145},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.01904761904761905},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.02100840336134454},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.042105263157894736},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.036585365853658534},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.040697674418604654},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.015189873417721518},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.03134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.043478260869565216},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.02304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01953125},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.013513513513513514},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.010178117048346057},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.052083333333333336},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.03773584905660377},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.011235955056179775},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.05154639175257732},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":2.5384615384615383},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.692439862542955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}},".":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875}}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}}}},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}},"o":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.019830028328611898},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.020833333333333332},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.02040816326530612},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.015723270440251572},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.01927710843373494},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112}}},",":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}},",":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},"o":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476}}}}}}},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}},"c":{"docs":{},"b":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}},"p":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}},"t":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},"l":{"docs":{},"i":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"s":{"docs":{},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809}}},"o":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.01904761904761905},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0215633423180593},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.011976047904191617},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01366120218579235}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"(":{"0":{"docs":{},"x":{"3":{"3":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"5":{"5":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"docs":{},"c":{"docs":{},"c":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}},"f":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}}}},"1":{"2":{"0":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"3":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},"docs":{}},"docs":{}},"2":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"4":{"0":{"9":{"6":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"_":{"docs":{},"i":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"x":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}}}},"o":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.05303030303030303}},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654}}}}}},"i":{"docs":{},"d":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},"r":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.045454545454545456},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}},"s":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}},"n":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776}}}},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.008403361344537815},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":3.0020366598778003},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.011461318051575931},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176}},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.033707865168539325},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":5.016129032258065},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":5.024590163934426}},".":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.02459016393442623}}},",":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"s":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"x":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},"o":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}},"g":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}}},"g":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.011824324324324325},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.012962962962962963},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},":":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}}},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}},"=":{"docs":{},"[":{"docs":{},"'":{"docs":{},"d":{"docs":{},"h":{"docs":{},"c":{"docs":{},"p":{"docs":{},"'":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},")":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"u":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}}}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}},"a":{"docs":{},"g":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}},".":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}},"i":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549}}}},",":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}}},"e":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}},"d":{"docs":{},"e":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.024096385542168676},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.01904761904761905},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.02112676056338028},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.016181229773462782},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.014678899082568808},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":3.345872518286311},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0326975476839237},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02389705882352941},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},":":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"s":{"docs":{},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},":":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}},")":{"docs":{},".":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},"_":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"4":{"docs":{},"_":{"5":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.07317073170731707}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"i":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"r":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"d":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"p":{"docs":{},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"documents/license.html":{"ref":"documents/license.html","tf":0.022900763358778626}},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}},"y":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}}},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"documents/license.html":{"ref":"documents/license.html","tf":0.030534351145038167}}}}}}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}},"n":{"docs":{},"t":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}},")":{"docs":{},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}},"r":{"docs":{},"i":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}},"_":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}},"i":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}},"k":{"docs":{},"i":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"i":{"docs":{},"l":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.03676470588235294}},"_":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"1":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},"s":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.014545454545454545}}}}}},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.0625},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}},"b":{"docs":{},"o":{"docs":{},"x":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}},"n":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"o":{"docs":{},"s":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.011824324324324325},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.018633540372670808}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}},"n":{"docs":{},"g":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"d":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.032196969696969696},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.0321285140562249},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.006535947712418301},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"=":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"6":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"7":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"docs":{}},"s":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},":":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"c":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}},"r":{"1":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},"_":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.022857142857142857}}}}}}}}}}}}}},"2":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}},"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.011976047904191617},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.033112582781456956},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.017142857142857144}},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.019867549668874173},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"1":{"2":{"3":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},"[":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"'":{"docs":{},"x":{"0":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}},"docs":{}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.038461538461538464}},"e":{"docs":{},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"t":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},")":{"docs":{},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}},"i":{"docs":{},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825}}}}},"r":{"1":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},"2":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943}}}},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}},"o":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},".":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"g":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}},"l":{"docs":{},"i":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":5.026148409893993}},"c":{"docs":{},"k":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.014678899082568808},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.014326647564469915},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.014084507042253521},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.025078369905956112},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.011824324324324325},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.030927835051546393},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.038922155688622756},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.018633540372670808},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.024390243902439025},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.008445945945945946},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.03125},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"/":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"/":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}},"p":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},",":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}}}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"x":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.013477088948787063},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0220125786163522},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.17647058823529413},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01092896174863388}},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},")":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"'":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"/":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"u":{"docs":{},"s":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}}},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}}}}},"u":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.07142857142857142}},".":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517}}}}},"c":{"docs":{},"k":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.013513513513513514},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"(":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},":":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"k":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},"p":{"1":{"1":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},"docs":{}},"docs":{}}}}},"r":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.022018348623853212},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.011824324324324325},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.020080321285140562},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.009398496240601503},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.007481296758104738},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.033707865168539325},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.021505376344086023},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},".":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}}}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},".":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"1":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}},"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"1":{"2":{"8":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023}},"i":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}},"c":{"8":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0225},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.020066889632107024},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.014634146341463415},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.021929824561403508},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.021834061135371178},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.022222222222222223},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}},"_":{"docs":{},"v":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},".":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}}},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":5.040983606557377},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}}}}}},"t":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}},"t":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.06756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512}},"+":{"docs":{},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}},"_":{"docs":{},"c":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"/":{"docs":{},"c":{"docs":{},"+":{"docs":{},"+":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789}}}},".":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"m":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}},"_":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":10.022222222222222}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"s":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}},"x":{"docs":{},"p":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"1":{"0":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}},"docs":{}},"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}}},"i":{"docs":{},":":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}},"q":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}}}}}}}},"d":{"docs":{},"c":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"p":{"docs":{},"u":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667}},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},"'":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}},"=":{"1":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"3":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"docs":{}}},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.019762845849802372}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},"[":{"1":{"6":{"docs":{},":":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},"'":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"'":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"u":{"docs":{},"m":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"s":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}},":":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"b":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}}}},"k":{"docs":{},"i":{"docs":{},"t":{"docs":{"products.html":{"ref":"products.html","tf":0.03333333333333333},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516}}},"n":{"docs":{},"d":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"b":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"p":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}}}},"y":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.017045454545454544},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.011976047904191617},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.02766798418972332},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.02493765586034913}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"u":{"docs":{},"p":{"docs":{},"t":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"=":{"docs":{},"'":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.02185792349726776}},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}}},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}}}}},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"p":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"n":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"_":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},"s":{"docs":{},"[":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}},"]":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"b":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}},"l":{"0":{"1":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":10.129032258064516},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":2.5703125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.04580152671755725}},"/":{"docs":{},"w":{"0":{"1":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}},"docs":{}},"docs":{}}},",":{"docs":{"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},":":{"docs":{"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516}}},"'":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}}}},"4":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":10.126984126984127},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},",":{"docs":{"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},":":{"docs":{"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872}}}},"docs":{}},"7":{"6":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}},"g":{"docs":{},"n":{"docs":{},"s":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.027777777777777776}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}}}}}}}}}}},"docs":{}},"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}},"i":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"p":{"docs":{},"o":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"n":{"docs":{},"k":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"u":{"docs":{},"x":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"o":{"docs":{},"s":{"docs":{},")":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"e":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},")":{"docs":{},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"g":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"b":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.02112676056338028},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.014678899082568808},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":5.064102564102564},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.09090909090909091},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.04081632653061224},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.008595988538681949},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.030927835051546393},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.7233676975945016},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"/":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"s":{"docs":{},"q":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}},"y":{"docs":{},".":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"\"":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},";":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"'":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}},"k":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}}},"_":{"docs":{},"a":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"s":{"2":{"docs":{},"h":{"docs":{},"h":{"1":{"2":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0106951871657754},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809}},"p":{"docs":{},"i":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"docs":{}},"docs":{}}}},"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},"e":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},".":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.017191977077363897}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}},"k":{"docs":{},"e":{"docs":{},":":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.016172506738544475},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.011976047904191617},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.023809523809523808},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012}},"w":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}}}}},"v":{"docs":{},"e":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},"f":{"docs":{},"e":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"documents/license.html":{"ref":"documents/license.html","tf":10.022900763358779}}},"c":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}},"e":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}},"l":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":10.036827195467422},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":5.002976190476191},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.014778325123152709},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":10.018867924528301},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":5.033707865168539},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":10.043668122270743},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":5.008},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.04580152671755725}}},"y":{"4":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.03273809523809524},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.064},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}},",":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008}}},":":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008}}}},"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236}}},"!":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}},"\"":{"docs":{},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419}}}}},"s":{"docs":{},".":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}},"'":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}},"'":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"r":{"docs":{},"a":{"docs":{"products.html":{"ref":"products.html","tf":0.02},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.014164305949008499},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.017045454545454544},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.023809523809523808},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.008403361344537815},"tutorials/lora/":{"ref":"tutorials/lora/","tf":5.076923076923077},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":2.5567375886524824},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.019704433497536946},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.02185792349726776},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":2.5198511166253104},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.04716981132075472},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.033707865168539325},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":10.033986928104575},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"/":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747}}}}}}}}},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}}}}}},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}}}}}}}}}}}},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":10.046511627906977},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.011363636363636364},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.028846153846153848},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":5.019704433497537},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":5.016393442622951},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.018300653594771243},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.03225806451612903},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.031746031746031744}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"a":{"docs":{},"s":{"9":{"2":{"3":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"docs":{}},"docs":{}},"docs":{}},"u":{"9":{"1":{"5":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"docs":{}},"docs":{}},"docs":{}},"b":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"d":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}}}}}}}}}}}}}},"l":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}}}}}}}},"e":{"docs":{},"u":{"8":{"6":{"8":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"(":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"r":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"a":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}}},"a":{"docs":{},"b":{"docs":{},"p":{"docs":{},",":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{},"t":{"docs":{},"o":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}},"u":{"docs":{},"s":{"9":{"1":{"5":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}}},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"_":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"[":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"b":{"docs":{},"w":{"docs":{},"_":{"1":{"2":{"5":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"w":{"docs":{},"_":{"1":{"2":{"5":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"docs":{}},"docs":{}},"2":{"5":{"0":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"docs":{}},"docs":{}},"docs":{}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"=":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"x":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"c":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"4":{"docs":{},"_":{"5":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"6":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"7":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"8":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"[":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"4":{"docs":{},"_":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"(":{"8":{"6":{"8":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"[":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}},"n":{"docs":{},"v":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"_":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"p":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"[":{"docs":{},"p":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"[":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"4":{"docs":{},"_":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"1":{"2":{"7":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"(":{"7":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"[":{"docs":{},"s":{"docs":{},"f":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}},"t":{"docs":{},"x":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}},"b":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"2":{"5":{"6":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"docs":{}},"docs":{}},"6":{"4":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"docs":{}},"docs":{}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}},"t":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},")":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":2.50709219858156}}},"e":{"docs":{},"u":{"8":{"6":{"8":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}},"=":{"2":{"0":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},"docs":{}},"docs":{}}}}}},"l":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.041666666666666664},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.03333333333333333},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}}}}}},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},"k":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.046153846153846156}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"a":{"docs":{},"c":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},"=":{"1":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},"docs":{}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666}}}},":":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"g":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"i":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"=":{"docs":{},"(":{"docs":{},"'":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}}}},".":{"docs":{"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}}},"c":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.03333333333333333},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01818181818181818}}}}}}}}},"n":{"docs":{},"g":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}},"s":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"e":{"docs":{},"/":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896}}}}},"o":{"docs":{},"k":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"u":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"s":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}},"p":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.022653721682847898},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},")":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},",":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},"/":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757}}}}}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}}}}}},"a":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"w":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"e":{"docs":{},"r":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"s":{"docs":{},"t":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"s":{"docs":{},"e":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"t":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"t":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0220125786163522},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.016867469879518072},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/lte/":{"ref":"tutorials/lte/","tf":5.05},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.04945054945054945},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.059322033898305086},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.011111111111111112},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":10.04516129032258},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},".":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}},"*":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"=":{"1":{"3":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"docs":{}},"docs":{}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}},"*":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"3":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"docs":{}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},":":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},":":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"*":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}}}}}}},"+":{"docs":{},"c":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"=":{"0":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}},"1":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}},"docs":{}}}}},"g":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"=":{"1":{"docs":{},",":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"p":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"b":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"d":{"docs":{},"s":{"docs":{},"p":{"docs":{},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"s":{"docs":{},"n":{"docs":{},"=":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}},"docs":{}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"?":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}},"(":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"r":{"3":{"2":{"9":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"0":{"1":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}},"e":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.012844036697247707},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":5.070422535211268},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549}},")":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577}},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}}}}}},"(":{"0":{"docs":{},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"1":{"docs":{},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"docs":{}}},"f":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"v":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"d":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.014256619144602852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}},"s":{"docs":{},"s":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},")":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"g":{"docs":{},"a":{"docs":{},"c":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"n":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"(":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}},"'":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"'":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"a":{"docs":{},"b":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}},"e":{"docs":{},"l":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.010126582278481013},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},".":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}},"r":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"e":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"'":{"docs":{},"}":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}}}}},"r":{"docs":{},"g":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00522875816993464},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"c":{"docs":{},"k":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"p":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}},"\"":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"s":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},":":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"\"":{"docs":{},")":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.01445466491458607},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"=":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},".":{"docs":{},".":{"docs":{},"/":{"docs":{},".":{"docs":{},".":{"docs":{},"/":{"docs":{},".":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"/":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"l":{"0":{"1":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"d":{"docs":{},"f":{"docs":{},")":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}}}}}}}}}}}},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},"s":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"u":{"docs":{},"x":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809}}}}},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}},"l":{"docs":{},"v":{"docs":{},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}}},"p":{"docs":{},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.005653710247349823}}}}}}},"o":{"docs":{},"e":{"docs":{},"m":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/oem/":{"ref":"datasheets/oem/","tf":5.153846153846154},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":2.5703125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":2.591666666666667},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},",":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},".":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},":":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},")":{"docs":{},";":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}}}}}},"a":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":5.010804321728691},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}},"a":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":5.019704433497537},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}}}},"_":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}},"m":{"docs":{},"v":{"docs":{},"[":{"docs":{},":":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"n":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"c":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"l":{"docs":{},"y":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},",":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476}}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}}},")":{"docs":{},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"t":{"docs":{},"o":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},"w":{"docs":{},"i":{"docs":{},"r":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":5.0175}},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"1":{"0":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}},"docs":{}},"docs":{}}}}}}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182}}}}}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"_":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}},"g":{"docs":{},"o":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},",":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"g":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"u":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.022727272727272728},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}},":":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"0":{"docs":{},"x":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"0":{"docs":{},"x":{"docs":{},"f":{"docs":{},"f":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{}}}}},"docs":{}},"s":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"docs":{},"[":{"1":{"docs":{},",":{"1":{"docs":{},",":{"1":{"docs":{},",":{"0":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},",":{"1":{"docs":{},",":{"1":{"docs":{},",":{"0":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},",":{"1":{"docs":{},",":{"1":{"docs":{},"]":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}},".":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}}}}},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"v":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.012903225806451613},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.014840989399293287},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875}}}},"a":{"docs":{},"l":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}},";":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"m":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}},"i":{"docs":{},"s":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"e":{"docs":{},"n":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.007339449541284404},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.02100840336134454},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.015789473684210527},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}},")":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}}}}},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789}}}}},"m":{"docs":{},"o":{"docs":{},"k":{"docs":{},"o":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"(":{"docs":{},"'":{"docs":{},"/":{"docs":{},"s":{"docs":{},"d":{"docs":{},"/":{"docs":{},"g":{"docs":{},"p":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"m":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},".":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},"\"":{"docs":{},".":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}},"i":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}}}},"/":{"docs":{},"o":{"docs":{},"n":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"_":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.009198423127463863},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.02459016393442623}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},".":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}},"docs":{}}}}}},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},":":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"s":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}},".":{"docs":{},"m":{"docs":{},"k":{"docs":{},"f":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"'":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}}}}}}},"s":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}},"d":{"docs":{},"u":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"(":{"docs":{},"'":{"docs":{},"/":{"docs":{},"s":{"docs":{},"d":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"/":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.022058823529411766},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"j":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.013245033112582781},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.013972055888223553},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.010183299389002037},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.019867549668874173},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.011826544021024968},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.023809523809523808},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.013108614232209739},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},";":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"'":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"c":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"s":{"docs":{},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.011461318051575931}}}}},"p":{"docs":{},"i":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}},"l":{"docs":{},"d":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},"e":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}},"w":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"n":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889}}}}}}},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},".":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}},"h":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"u":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.04285714285714286}},"n":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":2.5166666666666666}}}}}},"x":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},"q":{"docs":{},"u":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.014326647564469915},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.010183299389002037},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},")":{"docs":{},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"a":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}}}}}},"b":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"g":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164}}}}}},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}}}}}}}}}},"b":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"u":{"docs":{},"s":{"docs":{},"u":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}},"s":{"9":{"1":{"5":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.014164305949008499},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.01488095238095238},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.014577259475218658},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.02650602409638554},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.04819277108433735},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.020833333333333332},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.023809523809523808},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.035211267605633804},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.02018348623853211},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.04054054054054054},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.02100840336134454},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.021052631578947368},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.03048780487804878},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.013888888888888888},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.019886363636363636},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.012658227848101266},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.027247956403269755},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.008865248226950355},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0106951871657754},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0223463687150838},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.02857142857142857},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.03333333333333333},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.014705882352941176},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.007202881152460984},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.04807692307692308},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.02127659574468085},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.014778325123152709},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.01488833746898263},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.02197802197802198},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.0423728813559322},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.028077753779697623},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.015555555555555555},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.011278195488721804},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.023668639053254437},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.013972055888223553},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.015723270440251572},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.010183299389002037},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.018518518518518517},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.008905852417302799},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.041666666666666664},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.01241830065359477},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.016209476309226933},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.010752688172043012},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.019762845849802372},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.03678929765886288},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.013140604467805518},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.015772870662460567},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.01951219512195122},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0234375},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.015384615384615385},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.022058823529411766},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.03787878787878788},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.026143790849673203},"advance/cli.html":{"ref":"advance/cli.html","tf":0.011307420494699646},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"b":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.019830028328611898},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.020833333333333332},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.02040816326530612},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0220125786163522},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.016867469879518072},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.022222222222222223},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":3.3585434173669464},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.030141843971631204},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.038461538461538464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"\"":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},".":{"docs":{},".":{"docs":{},".":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"e":{"docs":{},"r":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.014326647564469915},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}},"e":{"docs":{},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827}}},"i":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}}},";":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"/":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}}}},",":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},":":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},":":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456}}}}}}}}},"g":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00522875816993464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.012720848056537103}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":10.008196721311476}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"m":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"f":{"docs":{},"m":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"f":{"docs":{},"m":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"f":{"docs":{},"m":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"m":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":10.00187265917603},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}},"s":{"docs":{},"l":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":10.0078125}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.024822695035460994},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"s":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}}}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"/":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"m":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":10.004878048780487}},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"(":{"7":{"5":{"0":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"docs":{}},"docs":{}},"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"7":{"2":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"p":{"docs":{},"u":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}},"m":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}},"g":{"docs":{},"m":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}}}},"m":{"docs":{},"k":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}},"c":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}},":":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"p":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.013333333333333334},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.022922636103151862},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":5.034722222222222},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.027777777777777776},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.02510460251046025},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.0625},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":5.01063829787234},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.008445945945945946},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":5.020408163265306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":3.3560115190784736},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.07692307692307693},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0392156862745098},"advance/cli.html":{"ref":"advance/cli.html","tf":5.012014134275619},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"r":{"docs":{},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577}}}}}},";":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}}}},"d":{"docs":{},",":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"_":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},"=":{"3":{"6":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"\\":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.020833333333333332},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.02159827213822894},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888}}}}}},"e":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.021798365122615803},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.038461538461538464},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.015463917525773196},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}},"o":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"\"":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"1":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}},"2":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":10.031936127744512}},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"9":{"6":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"b":{"docs":{},"a":{"docs":{},"u":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"=":{"9":{"6":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{}},"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}}}},"docs":{},"[":{"docs":{},"n":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}}}}}}},"x":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"x":{"docs":{},"_":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744}}}},"docs":{}},"/":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"_":{"1":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}}},"docs":{}}}}},".":{"docs":{},"f":{"docs":{},"l":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666}}}}},"u":{"docs":{},"c":{"docs":{},"p":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}},"r":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":10.007936507936508}},"l":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},":":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"'":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":10.015151515151516},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"5":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"1":{"1":{"2":{"2":{"3":{"3":{"4":{"4":{"5":{"5":{"6":{"6":{"7":{"7":{"8":{"8":{"9":{"9":{"docs":{},"a":{"docs":{},"a":{"docs":{},"b":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"docs":{},"c":{"0":{"0":{"0":{"0":{"0":{"1":{"0":{"0":{"0":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"1":{"1":{"docs":{},"b":{"0":{"2":{"8":{"2":{"docs":{},"a":{"1":{"8":{"9":{"docs":{},"b":{"7":{"5":{"docs":{},"b":{"0":{"docs":{},"b":{"4":{"docs":{},"d":{"2":{"docs":{},"d":{"8":{"docs":{},"c":{"7":{"docs":{},"f":{"docs":{},"a":{"3":{"8":{"5":{"4":{"8":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"2":{"docs":{},"b":{"7":{"docs":{},"e":{"1":{"5":{"1":{"6":{"2":{"8":{"docs":{},"a":{"docs":{},"e":{"docs":{},"d":{"2":{"docs":{},"a":{"6":{"docs":{},"a":{"docs":{},"b":{"docs":{},"f":{"7":{"1":{"5":{"8":{"8":{"0":{"9":{"docs":{},"c":{"docs":{},"f":{"4":{"docs":{},"f":{"3":{"docs":{},"c":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}}}}}},"docs":{}}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"7":{"0":{"docs":{},"b":{"3":{"docs":{},"d":{"5":{"7":{"docs":{},"e":{"docs":{},"d":{"0":{"0":{"0":{"8":{"docs":{},"c":{"docs":{},"d":{"6":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{},"b":{"5":{"7":{"docs":{},"f":{"3":{"6":{"docs":{},"d":{"8":{"8":{"6":{"9":{"1":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"5":{"docs":{},"e":{"docs":{},"e":{"8":{"6":{"5":{"9":{"3":{"2":{"0":{"1":{"6":{"9":{"docs":{},"a":{"6":{"1":{"docs":{},"c":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"a":{"docs":{},"d":{"docs":{},"a":{"4":{"docs":{},"d":{"docs":{},"a":{"docs":{},"e":{"3":{"docs":{},"a":{"docs":{},"c":{"1":{"2":{"6":{"7":{"6":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}}}},"docs":{}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}}},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}}}}}}},"b":{"docs":{},"'":{"1":{"2":{"3":{"4":{"5":{"docs":{},"'":{"docs":{},")":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"a":{"2":{"docs":{},"b":{"docs":{},"_":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"6":{"4":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}}}},"docs":{}},"docs":{}}}}}}}},"docs":{}},"b":{"2":{"docs":{},"a":{"docs":{},"_":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"6":{"4":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}}}},"docs":{}},"docs":{}}}}}}}},"docs":{}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"d":{"docs":{},"p":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},"l":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"p":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"i":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.00998003992015968},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},":":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"n":{"docs":{},"t":{"1":{"6":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"docs":{}},"docs":{}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}},"e":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":10.010752688172044}},".":{"docs":{},"a":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":10.003942181340342}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}}},"b":{"docs":{},"f":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"docs":{}},"docs":{}}}}}},"i":{"docs":{},"g":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}}},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"3":{"2":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"docs":{}},"8":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759}},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"docs":{}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":10.022222222222222}},".":{"docs":{},"d":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},"s":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},")":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},"f":{"docs":{},"p":{"docs":{},")":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}}}}},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}}}}}}}}}}}}}}}},"o":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":10.008888888888889}},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}},"d":{"docs":{},"u":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"_":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"w":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}}},"m":{"docs":{},"k":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}},"f":{"docs":{},"s":{"docs":{},"(":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}}}},"m":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"p":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"n":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":10.008695652173913}},".":{"docs":{},"m":{"docs":{},"d":{"5":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"docs":{}}},"s":{"docs":{},"h":{"docs":{},"a":{"1":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"2":{"2":{"4":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"docs":{}},"5":{"6":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"docs":{}},"docs":{}},"3":{"8":{"4":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"✔":{"docs":{"products.html":{"ref":"products.html","tf":0.2866666666666667}}},"n":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"g":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"n":{"docs":{},"o":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":2.5049627791563274},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872}}}},"m":{"docs":{},"e":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"\"":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}},"u":{"docs":{},"r":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.019830028328611898},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.023809523809523808},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.02040816326530612},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.02650602409638554},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.031055900621118012},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.031192660550458717},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.014084507042253521},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.033707865168539325},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.021505376344086023},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0196078431372549},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}},"s":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.009216589861751152},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.05813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":5.020057306590258},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.019886363636363636},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.02304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.007202881152460984},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.014778325123152709},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.016483516483516484},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":10.19047619047619},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.016666666666666666},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00980392156862745},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.010752688172043012},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":5.117647058823529},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}}}}}}}}}}},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"docs":{}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"docs":{}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}}}},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"docs":{}}}}}}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},"[":{"docs":{},"'":{"docs":{},"p":{"docs":{},"w":{"docs":{},"d":{"docs":{},"'":{"docs":{},"]":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}},"e":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"docs":{}},"]":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"docs":{}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"w":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.02510460251046025},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.02586206896551724},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.05714285714285714}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}},")":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"l":{"docs":{},"i":{"docs":{"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}},"n":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}}}},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"x":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"l":{"docs":{},"i":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}},"g":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"o":{"docs":{},"w":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"t":{"docs":{},"e":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":10.00909090909091},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":10.007936507936508},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}},"f":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"i":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}}},"h":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"a":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"b":{"docs":{},"l":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"d":{"docs":{},"e":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872}},"j":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028}},"s":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"=":{"docs":{},"'":{"docs":{},"g":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}}}}}}}},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"e":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.011976047904191617},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}},":":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"n":{"docs":{},"e":{"docs":{},"g":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}}}}}}}},"u":{"docs":{},"t":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},",":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"2":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},")":{"docs":{},":":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.03571428571428571},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.011278195488721804},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.013972055888223553},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.009198423127463863},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.04878048780487805},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.009363295880149813},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.01951219512195122},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.03225806451612903},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"s":{"docs":{},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}},"\"":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}},":":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"b":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.05},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":5.02542372881356},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"s":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"s":{"docs":{},"=":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"docs":{}}}}}}}}}},"v":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}},"m":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}},")":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577}},"_":{"docs":{},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"s":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},":":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}},"f":{"docs":{},"c":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025}},".":{"docs":{},"m":{"docs":{},"f":{"docs":{},"r":{"docs":{},"c":{"6":{"3":{"0":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"w":{"docs":{},"k":{"docs":{},"_":{"docs":{},"s":{"docs":{},"w":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},",":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"s":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"t":{"docs":{},"p":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}},"x":{"docs":{},"p":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}},"p":{"docs":{},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282}}}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"r":{"docs":{},"\\":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}}}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}}}}}},"b":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602}},"(":{"docs":{},".":{"docs":{},"g":{"docs":{},"z":{"docs":{},")":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},".":{"docs":{},"g":{"docs":{},"z":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602}}}}}}}},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"u":{"docs":{},"p":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"n":{"docs":{},"v":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"`":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}}}}}}},"p":{"1":{"0":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}},"9":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}},"`":{"docs":{},"p":{"1":{"1":{"docs":{},"`":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"4":{"docs":{},"`":{"docs":{},"`":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"docs":{}},"2":{"0":{"docs":{},"`":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"1":{"docs":{},"`":{"docs":{},"`":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"2":{"docs":{},"`":{"docs":{},"`":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"3":{"docs":{},"`":{"docs":{},"`":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"docs":{}},"4":{"docs":{},"`":{"docs":{},"`":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"docs":{}}}},"‘":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"'":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}}}}},"/":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"advance/cli.html":{"ref":"advance/cli.html","tf":0.009187279151943463}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"/":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"/":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517}},".":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"z":{"docs":{},"e":{"docs":{},"n":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464}}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"/":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"*":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"b":{"0":{"1":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.014962593516209476}}},"docs":{}}}}}}},"c":{"docs":{},"u":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"y":{"3":{"4":{"3":{"4":{"3":{"1":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"/":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"?":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"+":{"docs":{},"\"":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"?":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"1":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"/":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"g":{"docs":{},"z":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"r":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}},"{":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"}":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"\"":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"u":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}},"h":{"docs":{},"r":{"docs":{},".":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}}}}}},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}}}}}}}}}}}}}},"'":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"'":{"docs":{},":":{"docs":{},"'":{"2":{"6":{"0":{"4":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"p":{"docs":{},"w":{"docs":{},"d":{"docs":{},"'":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"p":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{},"w":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},",":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},",":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},",":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{},",":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},",":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},",":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},",":{"docs":{},"p":{"docs":{},"y":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{},"c":{"docs":{},"b":{"docs":{},",":{"docs":{},"n":{"docs":{},"v":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{},"l":{"docs":{},"p":{"docs":{},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},",":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"f":{"docs":{},"s":{"docs":{},",":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"}":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"1":{"0":{"9":{"5":{"docs":{},"d":{"docs":{},"f":{"8":{"2":{"1":{"3":{"docs":{},"a":{"docs":{},"a":{"docs":{},"c":{"2":{"9":{"8":{"3":{"docs":{},"e":{"docs":{},"f":{"docs":{},"d":{"6":{"8":{"docs":{},"d":{"docs":{},"b":{"docs":{},"a":{"9":{"4":{"2":{"0":{"docs":{},"c":{"8":{"docs":{},"e":{"docs":{},"f":{"docs":{},"c":{"9":{"docs":{},"c":{"7":{"docs":{},"c":{"4":{"docs":{},"a":{"docs":{},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"b":{"docs":{},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"docs":{}}},"docs":{}}},"3":{"5":{"4":{"3":{"4":{"7":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"\"":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"o":{"docs":{},"k":{"docs":{},".":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.02533783783783784},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"!":{"docs":{},"\"":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"b":{"docs":{},"b":{"docs":{},"\"":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}},"%":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}},"h":{"docs":{},"\"":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114}}}}},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},"\"":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"\"":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}}}}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"1":{"docs":{},".":{"1":{"4":{"4":{"docs":{},":":{"8":{"0":{"0":{"0":{"docs":{},"/":{"1":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"b":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"1":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"b":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}}},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"\"":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"\"":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"\"":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}},"u":{"docs":{},"b":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}},"i":{"docs":{},"'":{"docs":{},"m":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},"o":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}}}}},"p":{"docs":{},"y":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}}}},"c":{"docs":{},"c":{"6":{"9":{"1":{"4":{"docs":{},"a":{"4":{"5":{"7":{"docs":{},"e":{"docs":{},"b":{"4":{"docs":{},"a":{"docs":{},"f":{"8":{"8":{"5":{"5":{"docs":{},"e":{"docs":{},"c":{"0":{"2":{"docs":{},"f":{"6":{"9":{"0":{"9":{"3":{"1":{"6":{"5":{"2":{"6":{"docs":{},"b":{"docs":{},"d":{"docs":{},"d":{"0":{"8":{"docs":{},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"/":{"docs":{},"c":{"docs":{},"u":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}}}}}}}}}},"s":{"docs":{},"d":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"m":{"docs":{},"g":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}},"r":{"docs":{},"r":{"2":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"m":{"docs":{},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}},"\"":{"docs":{},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}},"t":{"docs":{},"r":{"2":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}}},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}}}}}}},"+":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"+":{"docs":{},"\"":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"+":{"docs":{},"\"":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}},"[":{"1":{"docs":{},"]":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"docs":{}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}}}}}}}}}},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}},"\"":{"docs":{},"\"":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.025}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},".":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"c":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}},"b":{"0":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"1":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"docs":{},"b":{"docs":{},"%":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"b":{"docs":{},"\"":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}}}}},"f":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"i":{"docs":{},"t":{"docs":{},"f":{"0":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}},"'":{"3":{"1":{"3":{"2":{"3":{"3":{"3":{"4":{"3":{"5":{"docs":{},"'":{"docs":{},"\"":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}},">":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}}}}},"'":{"1":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},"}":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"2":{"3":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}},"docs":{}},"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}},"docs":{}}},"1":{"7":{"8":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"2":{"5":{"5":{"docs":{},".":{"2":{"5":{"5":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}},"2":{"5":{"5":{"docs":{},".":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"6":{"0":{"4":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"docs":{}},"docs":{}},"docs":{},"'":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}}}},"8":{"docs":{},".":{"8":{"docs":{},".":{"8":{"docs":{},".":{"8":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.022058823529411766},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"'":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"'":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}}}}}},"g":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"t":{"docs":{},"e":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"'":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"'":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"'":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}},"'":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}},"d":{"docs":{},"e":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815}}}}}}},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}}},"t":{"docs":{},"f":{"8":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}}},"p":{"1":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"8":{"docs":{},"'":{"docs":{},"]":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}}},".":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.017191977077363897}}}}}},"docs":{}},"2":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}},"2":{"docs":{},"'":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}},"3":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496}}}}}},"docs":{}},"docs":{},"y":{"docs":{},"'":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"'":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}},"}":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"m":{"docs":{},"y":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"'":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}}}}}}}}}}},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"'":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"'":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}}}}}}}},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"d":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"/":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}},"b":{"docs":{},"c":{"docs":{},"'":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}},"t":{"docs":{},"o":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"'":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"{":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{},"{":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{},"{":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},":":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"}":{"docs":{},"}":{"docs":{},"}":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"i":{"docs":{},"d":{"docs":{},"'":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"{":{"docs":{},":":{"docs":{},"d":{"docs":{},"}":{"docs":{},"'":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}}}}}}}}}}}}}}}}}}}},"\\":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}},"x":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}},"r":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"+":{"1":{"4":{"docs":{},"d":{"docs":{},"b":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"docs":{}},"2":{"2":{"docs":{},"d":{"docs":{},"b":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"docs":{}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.028716216216216218},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.014705882352941176},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.03787878787878788}},"=":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"p":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}},"?":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},"=":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.02912621359223301},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.022727272727272728},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.010638297872340425},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.0380952380952381},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0431266846361186},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.017964071856287425},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0374331550802139},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.04377880184331797},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.07407407407407407},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0625},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.03571428571428571},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.11904761904761904},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.1025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0392156862745098},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.09},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.022058823529411766},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.008403361344537815},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.054924242424242424},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.04964539007092199},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.04433497536945813},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.0546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.07692307692307693},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.11320754716981132},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.016483516483516484},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.05555555555555555},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.07407407407407407},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0625},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.009398496240601503},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.01545253863134658},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.01775147928994083},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.013513513513513514},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.018867924528301886},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.020689655172413793},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.010183299389002037},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.020356234096692113},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.04716981132075472},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.045714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.018300653594771243},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.014962593516209476},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.023715415019762844},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.019438444924406047},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.03125},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.008595988538681949},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01639344262295082},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"=":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}},">":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.018808777429467086},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},">":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},">":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.020833333333333332},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0670391061452514},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},".":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"=":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"=":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"[":{"0":{"docs":{},"x":{"1":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"4":{"3":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}},"docs":{}},"docs":{}},"]":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655}}}},"3":{"3":{"0":{"8":{"0":{"docs":{},"]":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"6":{"3":{"8":{"docs":{},"]":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"advance/cli.html":{"ref":"advance/cli.html","tf":0.03816254416961131}},"'":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},"p":{"1":{"7":{"docs":{},"'":{"docs":{},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.017191977077363897}}}}},"docs":{}},"docs":{}}},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"]":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}},"]":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"]":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"c":{"docs":{},"c":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"[":{"0":{"docs":{},"x":{"4":{"3":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}},"docs":{}},"docs":{}}},"docs":{}},"(":{"0":{"docs":{},"x":{"0":{"0":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"1":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"w":{"docs":{},"]":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}},"o":{"docs":{},"b":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}}}}},"n":{"docs":{},"/":{"docs":{},"a":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}},"x":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.016181229773462782},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.04727272727272727},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"x":{"docs":{},"x":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"x":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}}}},"m":{"docs":{},"l":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.08727272727272728}},"x":{"docs":{},".":{"docs":{},"x":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"/":{"docs":{},"y":{"docs":{},"/":{"docs":{},"z":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"^":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},"q":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":2.5096153846153846}},"l":{"docs":{},"i":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334}}}}}}},"t":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}},"o":{"docs":{},"t":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}},"e":{"docs":{},"u":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"e":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"r":{"docs":{},"i":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"|":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.058823529411764705},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.01576872536136662},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},"=":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"$":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.008865248226950355},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}}}}}},"i":{"docs":{},"d":{"docs":{},"f":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"y":{"docs":{},"/":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"/":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.012468827930174564}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\\":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"n":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"+":{"docs":{},"c":{"docs":{},"g":{"docs":{},"s":{"docs":{},"n":{"docs":{},":":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}}}}},"~":{"docs":{},"/":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"r":{"docs":{},"c":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"m":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"m":{"docs":{},"k":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}},"r":{"docs":{},"c":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"/":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}},"%":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.026143790849673203},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"s":{"docs":{},"\"":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"'":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"x":{"docs":{},"'":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"d":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"'":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},"s":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"f":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943}}}},"—":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}},"“":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"=":{"docs":{},"/":{"docs":{},"u":{"docs":{},"s":{"docs":{},"r":{"docs":{},"/":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"2":{"docs":{},".":{"7":{"docs":{},"”":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"”":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"x":{"docs":{},"\"":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"a":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{},"”":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"”":{"docs":{},")":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}}}}}},"}":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"?":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}},"!":{"docs":{},"?":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"?":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},"z":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}}},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"r":{"docs":{},"o":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"i":{"docs":{},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}},"s":{"docs":{},"p":{"0":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}},",":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}},".":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.07777777777777778}}}},"–":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889}}},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"_":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.009925558312655087}}}}}}}}}}}}}}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"_":{"docs":{},"_":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},")":{"docs":{},":":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"b":{"docs":{},"_":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.05},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":10.009230769230768},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"docs":{},"[":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}},"*":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"?":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},"*":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"*":{"docs":{},"*":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}},"e":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}}}}}},"!":{"docs":{},"=":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},".":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"\"":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"e":{"docs":{},"u":{"8":{"6":{"8":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}},"]":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}}}},"​":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.022321428571428572}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}},"a":{"docs":{},"w":{"docs":{"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}}}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.017278617710583154},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}}},"@":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}},"→":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.0449438202247191},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082}}}},"length":23175},"corpusTokens":["!.","!=","\"","\"!\"","\"!bb\"","\"!bb%ds\"","\"!bh\"","\"\"\"","\")","\")[1]","\"+net_to_use+\"","\"+self.basic+\"\\r\\n\\r\\n\")","\"+str(return_code))","\"...","\"/dev/cu.usbseri","\"/sd/appimg.bin\"","\"1.0.1b\"","\"1095df8213aac2983efd68dba9420c8efc9c7c4a\"","\"354347xxxxxxxxx\"\\r\\n\\r\\nok.","\">","\"accepted\":","\"add","\"address\":","\"arr\":","\"arr2\":","\"b'3132333435'\"","\"b0\":","\"b1\":","\"bb%ds\"","\"bbb\"","\"bf\"),","\"big\").","\"bitf0\":","\"bitness\"","\"ccc6914a457eb4af8855ec02f6909316526bdd08\"","\"connect","\"copyright\",","\"credits\"","\"deep","\"delete\":","\"deltalistener\"","\"descriptor\"","\"devic","\"dst_path\":","\"eras","\"feed\"","\"field_name\":","\"firmware\":","\"flash\"","\"flash/changed_file.py\",","\"flash/lib/new_lib.py\",","\"flash/old_file.py\",","\"flash/other_old_file.py\"","\"forc","\"foreign","\"forever\".","\"hash\":","\"heartbeat\"","\"hello","\"hello,","\"help\",","\"help()\"","\"host\"","\"http://192.168.1.144:8000/1.0.1b/flash/changed_file.py\",","\"http://192.168.1.144:8000/1.0.1b/flash/lib/new_lib.py\",","\"http://192.168.1.144:8000/firmware_1.0.1b.bin\",","\"i'm","\"idle\"","\"io.adafruit.com\",user=\"your_username\",","\"license\"","\"mi","\"micro","\"micro\",","\"micropython\"","\"new\"","\"new\":","\"old\"","\"over","\"password\":","\"paste_your_serial_port_here\",","\"ptr\":","\"ptr2\":","\"pybyt","\"python\",","\"rb\")","\"recovery\"","\"rejected\":","\"safe","\"scripts\"","\"secur","\"shadowecho\"","\"shadowupdater\"","\"special\"","\"stall\"","\"sub\":","\"sync_folder\":","\"these","\"timeout\":","\"tradit","\"update\":","\"url\":","\"username\":","\"version\":","\"wifipassword\"),","#","#!/usr/bin/env","##","#################","##################","#######################","########################","#(should","#):","#0","#client_id","#config","#conn_disconn_timeout","#connect","#f.write(\"{}","#flag","#from","#mqtt_oper_timeout","#pi","#thing_nam","$","$idf_path/components/esptool_py/esptool/espefuse.pi","$idf_path/components/esptool_py/esptool/espsecure.pi","$idf_path/components/esptool_py/esptool/esptool.pi","$pycom","$user","%","%d","%d'","%ds:","%f","%s\"","%s'","%x'","&","'","'',","'':","''},","'.join('{:d}'.format(x)","'/flash/cert/aws_client.cert'","'/flash/cert/aws_private.key'","'/flash/cert/aws_root.ca'","'/path/to/catm1","'/path/to/updater.elf')","'/sd')","'/sd/updater.elf')","'10.0.0.1')},","'10.0.0.1',","'123')","'192.168.0.1'))","'192.168.0.1',","'192.168.178.1',","'2'","'255.255.0.0',","'255.255.255.0',","'2604","'8.8.8.8'))","'\\n')","'abc'","'abc')","'aws_host_url'","'bluetooth',","'de","'devic","'failure'","'fffe'","'fipy')","'gpy',","'handshake'","'heart","'hello'","'hello')","'lopy',","'lte","'my_network_key'))","'my_wifi_password'","'my_wifi_ssid'","'mywifi':","'mywifikey'),","'networkid':","'p11'))","'p18'])","'p18'].","'p21')","'p21',","'p22',","'p23'))","'password'),","'publishtopic'","'py'","'pycompublishclient'","'pypypypypypypypypypypypypypypypypypypypy'","'python'),","'r')","'sigfox',","'sipy',","'success'","'to","'true'","'usb","'username',","'utf8')","'w')","'wifi'","'wifi',","'wipy'","'wlan_config'","'wlan_config':","'xy')","'your","'{\"state\":{\"desired\":{\"property\":'","'}}}'","(","(\"little\"","(%)","('10.0.0.114',","('10.0.0.8',","('c).","('wipy',","(((data[0]","((l_rom[byte]","((~temp_read","(*.pem.crt)","(*.private.pem.key)","(0","(0)","(0),","(0).","(0.0,","(0x020,","(0x040,","(0x1a0000)","(0x200,","(0xf013","(0xf014for","(1","(1)","(1),","(1,","(1,0,1)","(1,0,1,0,1,0,1,0,1)","(1,0,1,1,0,1)","(1,0,1,1,1,0,1,0,1)","(1.19.0","(10.11","(100,","(16","(2),","(2):","(2**exp).","(2,","(200)","(23)","(2g)","(3","(3)","(30000","(32","(4).","(4,","(400,200,100,300,200,400)","(4kib).","(8","(8000,11000,8000,11000,6000,13000,6000,3000,8000)","(868","(>=","(``p10``,","(``p19``,","(``p20``","(``p20``,","(``p3``","(a","(abp)","(abp).","(accelerometer,","(ack","(activ","(advanc","(ae","(after","(all,","(along","(also","(amazon","(and","(ap)","(apm","(apm)","(appeui)","(appkey)","(apple'","(arg.id()))","(at","(atqa),","(att),","(base64)","(becaus","(between","(bi","(bit","(ble)","(boot.py)","(bq24040","(bt_o):","(but","(button","(byte","(bytes,","(c)","(call","(can","(cdc)","(chain)","(char.properties()","(check_uid(list(uid),","(clang","(class","(clk,","(com","(commonli","(config.py):","(configur","(conn,","(connect","(correspond","(count_per_c","(crc","(csv)","(current","(data","(data,","(default)","(default,","(default:","(details).","(dev_addr,","(dev_eui,","(deveui)","(devic","(device_id","(device_id,","(do","(doesn't","(domoticz.py)","(e.g","(e.g.","(e.g.,","(e.g:","(eg","(either","(enabl","(encod","(europe)","(even","(except","(express","(extended).","(extern","(f013","(f014","(family,","(fast)","(filter,","(fipy,","(flash_encryption_key.bin","(float),","(for","(foreign","(function","(g).","(gap)","(high/low)","(hint:","(http://epydoc.sourceforge.net/stdlib/distutils.version.loosevers","(i","(i.e","(i.e.","(id,","(id=0x012,","(if","(ignor","(in","(inact","(includ","(input,","(insecure).","(integer)","(integer).","(ip,","(ipv4_address,","(it","(it'","(iv)","(join","(just","(l01,","(l76","(len","(len(recv_ack)","(len(recv_pkg)","(level,","(like","(lis2hh12)","(locat","(lopi","(lopy,","(lopy4,","(lora","(lora.lora).","(lora.lora):","(low","(lowercase)","(lpmac,","(ltr","(m)","(m).","(m,","(mac,","(main.py)","(major,","(make","(mani","(max","(may","(mfrc6300)","(mfrc63002hn)","(mfrc630_mf_auth_key_a","(micropython)","(mit)","(modbu","(mpl3115a2)","(must","(names)","(never","(nfc,","(no","(nodes)","(none,","(normal","(not","(note","(note:","(obj,","(often","(on","(on/off)","(onli","(optional)","(or","(ota)","(otaa)","(over","(p0)","(p1)","(p10","(p10=sda,","(p12)","(pa),","(pa).","(pack","(partit","(pic","(pin#6","(pin='p12')","(power","(putty,","(pybyt","(pycom","(pysense/pytrack),","(python","(quectel","(raw","(rb","(re)init","(read","(recommended)","(recv_data)","(regard","(remot","(repl)","(requir","(resolution)","(rgb","(rgb_bright","(rtc).","(rtr=true).","(rx_timestamp,","(same","(save","(scl)","(scl).","(sda)","(sda,","(sec,","(sec,).","(see","(select","(sequence)","(server)","(si7006","(si7006a20)","(silver","(sipy)","(sntp).","(so","(so_*","(ssid","(ssid,","(standard)","(such","(sysname='gpy',","(telnet)","(temp_msb","(that","(the","(thi","(though","(total","(true","(true):","(ttn)","(tuple)","(tx1/rx1),","(txd/rxd","(typenam","(typic","(tz","(uart)","(ubinascii.hexlify(lora.mac()).decode('ascii')))","(uctypes.array","(uctypes.ptr","(universal)","(unlik","(updat","(uplink_frequency_hz,","(upon","(use","(user","(v","(via","(wait","(wake_reason,","(wakeup)","(we","(which","(with","(wlan.ap","(write","(x86)\\pycom\\pycom","(year,","(you","({m,n}),","(~","(~0.4","(~0.8","(~1.5","(~1ua",").","*","**","****","**environ","*,","*.","*?","+","+14dbm","+22dbm","+=","+?","+pi).",",",",\"\")",",region=lora.eu868,",",timeout=none,",".","...","...)","./pyupgrad",".atom\\packages\\pymakr\\",".bin)",".callback()",".cb",".nv",".ota",".pi",".read()",".tar",".tar(.gz)",".tar.gz",".zip","/","//","/dev/cu.bluetooth","/dev/cu.usbmodempy343431","/dev/cu.usbseri","/dev/tty.usbmodem*","/dev/ttyusb0","/dev/ttyusb01","/flash","/flash.","/flash/boot.py:","/flash/cert","/flash/cert.","/flash/cert/","/flash/cert/.","/frozen","/json.htm?\"+path+\"","/lib","/manifest.json?current_ver=1.0.0","/path/to/firmware/archive.tar.gz","/sd","/sd.","/usr/local/bin.","0","0%","0)","0))","0),","0):","0);","0,","0.","0.1","0.2).","0.5","0.9","004:","005:","00:00:00","01","01)","0100","02","020","04d8","04d8:f013","04d8:f014","08","09:51:46","0:","0dbv","0x0","0x0,","0x00,","0x0000","0x001","0x00ff00","0x01","0x010),","0x010,","0x01:","0x02","0x02,","0x020","0x03","0x03,","0x030","0x030),","0x03]))","0x03]):","0x04","0x04,","0x040","0x04d8.","0x05","0x05,","0x050)])","0x050.","0x05]))","0x05]),","0x06","0x06,","0x06]))","0x07,","0x08","0x08]))","0x0f","0x0f)","0x10","0x10,","0x100,","0x1000).","0x10000","0x18","0x1a0000).","0x200,","0x28:","0x300","0x300,","0x400","0x400])","0x42","0x42,","0x77","0x7f","0x7fc)])","0x7ff),","0x8","0x80","0x8000","0x95,","0xdd,","0xef37","0xef38","0xef98","0xef99","0xf011","0xf012","0xf013","0xf014","0xf1:","0xf8],","0xf9]]","0xff)","0xff00","0}),","1","1\"')","1')","1)","1).","1);","1,","1.","1..254","1.0","1.0)","1.0.0","1.0.1","1.0.2","1.0.99","1.0.x","1.1,0,0","1.12.0.b0","1.14.3).","1.16.0.b1","1.16.x","1.17.0.b1","1.17.5.b6","1.1v","1.1v.","1.2.5,","1.25","1.4","1.5","10","10%","10)","10),","10,","10,000u","100","100%","100%.","100)","100):","1000","1000*100n","1000*channel","10000","100000.","1000000.","1000n","1000u","100hz,","100ma.","100n","100u","100us.","102.4","1024]","10:","10:30am","10h","10k","10m","10ma.","10ua","10ua.","11,","11.","1120.","115200","115200)","11bit","11db.","12","12,","12.","120m","122hz.","123","12341","125","125hz","128","128),","128,","12:","12]))","12dbv","13","13,","13604","14","14.04","146","14:23:58)","15","151","16","16\",","16.","16384","180","180.","18dbv","19.7µa","192),","192,","192.168.1.144:8000\\r\\n\\r\\n","192.168.4.1","192.168.4.1)","192.168.4.1,","1970","1:","1])","1khz","1st","2","2')","2)","2),","2):","2**e","2,","2.","2.0","2.0,","2.0exp","2.4ghz","2.5","2.7:","2.x.","20","20*100n","200","200)","200):","2000","2000.","20000.","2000mg","2005","2009","200m","2010","2013","2014).","2015","2016","2017","2017,","2018","2018,","2048","20khz","21;","224","23","230400.","24","25","25)","250","254","255","256","256)","256,","27',","28,","28.","29bit","2:","2]","2g/3g/lte","2g/gprs,","2ma","2mhz","2nd","2u","3","3)","3,","3.","3.0","3.0,","3.0.","3.0disconnect","3.0pytrack/pysense/pyscanusb","3.2768","3.3v","3.3v,","3.3v.","3.4v","3.5","3.5,","3.5.","3.5v","3.6.5","3.x,","30","30%","30,","300k","306076","31","31)","31.","3125n","32","32\",","32.","32.768","32768","329al","32:","366","375","37781.dup","37781.dup',","37781.dup)","37781.zip","384","38638.dup","38638.dup')","38638.dup',","38638.zip","3:","3]))","3d.","3gpp","3rd","3v3","3v3).","3vpp","4","4,","4.2.1","4/5","4096","433mhz","433mhz.","443)[0][","450ma.","48","48).","48656c6c6f","4:","4kib","4mb","4mb.","4s","5","5)","5,","5.0.0.0d","5.1.1.0","5.5","5.5v","5.5v.","50%","5000","5000m","500:","500u","512","512kb","54854","59","5996938","5khz","5th","5v","6","6,","60","600","64","64\"","64).","64.","65","65535.","6dbv","7","7).","7,","7.","7.8.0","70,","70b3d5499585fca1.","71","78","7ua","8","8'))","8,","8.","8.8.8.8,","8/10/+,","8/10/+.","80","80%","80)[0][","8000","8000)","8080","80m","8192","8441)[0][","849","863","863000000","868","868000000","868000000,","868mhz","868mhz/915mhz","870000000","8883","8]))","8mb","8mb.","9","9):","9,","9.1.0","90","90.","902.0.39.1)]","902000000","912","915","915mhz","921600","921600.","928","928000000","9600)","99%.",":","=","==","==============",">",">=",">>",">>=",">>>",">>>,",">>>.","?","?!?","??","@","@,","[","[########################################]","['lora',","['p17',","[(0x001,","[(0x100,","[0]","[0x100,","[0x43,","[33080]","[38638]","[=========================]","[[0x43,","[]","[command","[command]","[e.sec","[gcc","[global","[n/a]","[pytrack]","[r]","[rom]","[usb","[w].","[wob]","[wob]]","\\","\\.","\\n\\n\")","\\r\\n+cgsn:","],","^","__init__(self):","__init__(self,","_lib/pycoproc_","_lora_pkg_ack_format","_lora_pkg_format","_search_rom(self,","_seconds_handler(self,","_stub_","_thread","_thread.allocate_lock()","_thread.exit()","_thread.get_ident()","_thread.locktyp","_thread.stack_size([size])","_thread.start_new_thread(discovery_loop,","_thread.start_new_thread(function,","_thread.start_new_thread(th_func,","`","``p11``","``p14``)","``p20``","``p21``)","``p21``,","``p22``and","``p23``)","``p4``)","`devic","`p10`","`p9`","`start_level`","a20)","a_lock","a_lock:","ab001234\",","abc1de45bf).","abi","abi,","abil","abov","above)","above,","above.","abp","abs()","abs_done_0","absolut","abstract","acc","acc.enable_activity_interrupt(2000,","acc.pitch()","acc.roll()","acceler","acceleration,","acceleromet","accelerometer,","accelerometer.","accelerometer:","accept","accepted!\")","accepted.","access","access.","accessori","accommod","accord","accordingly.","account","account.","account:","accur","achiev","ack","ack_pkg","acquir","act","action","action.","activ","activated,","activated.","activation)","activation:","activation;","active.","activities.","activity/inact","actual","ad","adafruit","adafruit'","adapt","adapterwifilook","adapterwifiwhen","adc","adc()","adc(0)","adc.","adc.attn_0db,","adc.attn_11db","adc.attn_2_5db,","adc.attn_6db,","adc.channel","adc.channel(*","adc.channel(pin='p13')","adc.channel(pin='p16')","adc.channel(pin='p16',","adc.deinit()","adc.init(","adc.vref(1100)","adc.vref(vref)","adc.vref_to_pin('p22')","adc.vref_to_pin(pin)","adc_c","adc_c()","adc_c.value()","adcchannel","adcchannel()","adcchannel.","adcchannel.deinit()","adcchannel.init()","adcchannel.value()","adcchannel.value_to_voltage(value)","adcchannel.voltage()","add","add(1,","add(number1,","add.","added!","added,","addit","additional,","additionally,","addr","addr.","addr=0x23,","addr=i2c.scan()[0])","addr_typ","addr_type,","address","address)","address,","address.","address/credentials,","address:","address:\"","address]","address_book","addrsiz","addrsize=8)","adher","adjust","adr","adr,","adr=false,","adr=true,","adv","adv:","adv_typ","adv_type,","advanc","advertis","advertised.","advertisement.","advertisements,","advertisements.","advertiser.","advertiser:","advertising.","ae","aes(key,","aes.mode_cbc:","aes.mode_cfb","aes.mode_cfb,","aes.mode_cfb.","aes.mode_cfb:","aes.mode_crt.","aes.mode_ctr.","aes.mode_ctr:","aes.mode_ecb","aes.mode_ecb.","aes.mode_ecb:","aes.segment_128","aes.segment_128:","aes.segment_8","aes.segment_8,","affect","africa.","after,","after.","again","again.","against","aggreg","agnost","aim","air","air\"","air:","alarm","alarm):","alarm.","alarm.callback(handler,","alarm.callback(none)","alarm.cancel()","alarm:","alarms.","alex!\"","algorithms.","alia","align","alive.","all()","all:","alloc","allocated,","allocated.","allow","allowed),","allows,","allows.","along","alongsid","alphanumer","alreadi","als_gain_1x,","als_gain_1x,als_gain_2x,","als_gain_48x,","als_gain_4x,","als_gain_8x,","als_gain_96x","als_int_100,","als_int_150,","als_int_200,","als_int_250,","als_int_300,","als_int_350,","als_int_400","als_int_50,","als_rate_100,","als_rate_1000,","als_rate_200,","als_rate_2000","als_rate_50,","als_rate_500)","als_rate_500,","also,","alt","alt)","alt=","alter","altern","alternatively,","although","altimet","altitud","altium","alway","always_on","amazon","ambient","ambiguity.","ambl","amount","amount.","amplitud","amplitude)","analog","analogu","anchored).","and/or","anoth","another,","another.","answer","answer.","antenna","antenna),","antenna,","antenna.","antenna=none)","antenna=none,","antenna=wlan.int_ant)","anticip","any()","any)","any).","any...)","anymore.","anyth","anyway","ap","ap)","ap.","api","api).","api.","apin","apin()","apm","app_eui","app_eui,","app_key","app_key)","app_key),","app_swkey","app_swkey))","app_swkey).","appar","appear","appear,","appear.","appear:","appears,","appears.","append","appeui","appimg","appimg.bin","appkey","appkey)","appkey.","appl","appli","applic","application)","application,","application.","applications,","applications.","applied,","applied.","approach.","appropri","approxim","apr","apt","arbitrari","arbitrarili","arch:","architecture.","archiv","archive,","archive.","arduino,","are.","are:","area","area.","arg","arg:","arg=none)","arg=none,","argentina.","args[,","argument","argument,","argument.","arguments,","arguments.","arguments:","aris","arithmet","around","array","array,","array.","array.append(val)","array.array(typecode[,","array.extend(iterable)","arriv","arrive.","arrow","articl","artifact","as923","ascii","asia","ask","aspir","assert","asserted,","assertions,","asset","asset_that_will_be_removed.wav","assign","assist","associ","assum","astrik","asynchron","at&t,","at.","at:","atmospher","atom","atom,","atom.","atom/vscod","att","attach","attempt","attempted.","attend","attenu","attn","attn=adc.attn_0db)","attn=adc.attn_11db)","attribut","attributes:","au915]","australia","australia,","auth","auth,","auth:","auth=(app_eui,","auth=(dev_addr,","auth=(dev_eui,","auth=(net.sec,","auth=(network.wlan.wpa2,","auth=(wlan.wpa2,","auth=(wlan.wpa2,'www.wipy.io'),","auth=(wlan.wpa2_ent,","auth=(wlan.wpa2_ent,),","auth=none,","auth=original_auth,","authent","authenticated,","authentication.","author","authoris","authorise.","auto","autom","automat","automatically).","automatically,","automatically:","avail","availability/non","available,","available.","available_net","available_nets])","avoid","aw","await","awar","aware,","away","awoken","aws,","aws.","aws_client_cert","aws_host","aws_port","aws_private_key","aws_root_ca","awsiotmqttclient(config.client_id)","awsiotmqttshadowclient(config.client_id)","axi","axis.","b","b'456')","b'notsuchsecretkey'","b'ping':","b,","b:","b]","back","back,","back.","backend","backend).","backend,","backend.","background.","backlog","backup","backup.","backup.cb","backup.nv","backup.ota","bag","band","band,","band.","band=20\"')","band=none)","bands.","bandwidth","bandwidth:","bandwidth=lora.bw_125khz,","bang","bar","bare","baremet","barometr","base","base64","baseboard","basi","basic","basic):","basis.","batteri","battery,","baud","baudrat","baudrate.","baudrate=100000)","baudrate=100000,","baudrate=1000000,","baudrate=20000)","baudrate=2000000,","baudrate=500000,","baudrate=9600)","baudrate=9600,","be","be,","be.","be:","bear","beat.","becom","befor","before.","begin","beginn","beginners,","beginning.","behav","behaviour","behaviour).","behaviour.","behind","being,","belong","below","below).","below,","below.","below:","benefit","besid","best","better","between","beyond","bf_len","bf_po","bh%ds.","bh1750fvi","bh1750fvi.bh1750fvi(i2c,","bh1750fvi.py.","bh1750fvi:","bi","big","bigger","bin()","binari","binaries:","binascii","binascii.hexlify(machine.unique_id())","binascii.hexlify(wl.mac())[6:]","binascii.hexlify(wl.mac())[:6]","binascii.unhexlify('00000005'))[0]","bind","bind()","bit","bit)","bit,","bit.","bit/pulse,","bit:","bitfield","bitfield).","bitfield,","bitfields:","bits,","bits.","bits=12)","bits=8,","bitwis","black","blank","blank,","ble","blink","blink.","block","block)","block,","block.","block:","block_address","blocked.","blocking,","blocksiz","blue","blue,","blue.","bluetooth","bluetooth()","bluetooth,","bluetooth.adv_128service_data,","bluetooth.adv_128srv_cmpl,","bluetooth.adv_128srv_part,","bluetooth.adv_16srv_part,","bluetooth.adv_32service_data,","bluetooth.adv_32srv_cmpl,","bluetooth.adv_32srv_part,","bluetooth.adv_adv_int,","bluetooth.adv_appearance,","bluetooth.adv_dev_class,","bluetooth.adv_flag,","bluetooth.adv_manufacturer_data","bluetooth.adv_manufacturer_data)","bluetooth.adv_name_cmpl)","bluetooth.adv_name_cmpl))","bluetooth.adv_name_cmpl,","bluetooth.adv_name_short,","bluetooth.adv_service_data,","bluetooth.adv_t16srv_cmpl,","bluetooth.adv_tx_pwr,","bluetooth.advertise([enable])","bluetooth.advertise(true)","bluetooth.bl","bluetooth.callback(trigger=bluetooth.client_connect","bluetooth.callback(trigger=none,","bluetooth.char_notify_ev","bluetooth.char_notify_event.","bluetooth.char_read_ev","bluetooth.char_read_event,","bluetooth.char_write_event,","bluetooth.char_write_event.","bluetooth.char_write_event:","bluetooth.client_connected,","bluetooth.client_connected:","bluetooth.client_disconnect","bluetooth.client_disconnected,","bluetooth.client_disconnected:","bluetooth.conn_adv,","bluetooth.conn_dir_adv,","bluetooth.connect('112233eeddff')","bluetooth.connect(adv.mac)","bluetooth.connect(mac_addr)","bluetooth.deinit()","bluetooth.disc_adv,","bluetooth.disconnect_client()","bluetooth.events()","bluetooth.ext_","bluetooth.ext_ant.","bluetooth.get_adv()","bluetooth.get_advertisements()","bluetooth.init(id=0,","bluetooth.int_ant,","bluetooth.isscanning()","bluetooth.isscanning():","bluetooth.new_adv_event,","bluetooth.non_conn_adv,","bluetooth.prop_auth,","bluetooth.prop_broadcast,","bluetooth.prop_ext_prop","bluetooth.prop_indicate,","bluetooth.prop_notify,","bluetooth.prop_read):","bluetooth.prop_read,","bluetooth.prop_write,","bluetooth.prop_write_nr,","bluetooth.public_addr,","bluetooth.public_rpa_addr,","bluetooth.random_addr,","bluetooth.random_rpa_addr","bluetooth.resolve_adv_data(adv.data,","bluetooth.resolve_adv_data(data,","bluetooth.scan_rsp","bluetooth.service('abc123')","bluetooth.service(uuid,","bluetooth.service(uuid=b'1234567890123456',","bluetooth.set_advertisement(*","bluetooth.set_advertisement(name=\"advert\",","bluetooth.set_advertisement(name='lopy',","bluetooth.start_scan(","bluetooth.start_scan(10)","bluetooth.start_scan(20)","bluetooth.start_scan(timeout)","bluetooth.stop_scan()","bluetoothserverservice.","blynk","board","board'","board).","board,","board.","board/embed","board/soc","board/soc.","board=gpi","boards,","boards.","book","book.","bool","boolean","boolean.","boot","boot\"","boot,","boot.","boot.pi","boot.py.","boot:","boot;","booting,","bootload","bootloader,","bootloader.bin","bootloader0","bootloader1","bootloader1*","bootloader2","bootloader2*","bootrom","boots,","boots.","both","both.","bottom","bound","bound.","box","box!","brace","branch","brazil.","break","brew","bright","bring","broadcast","broken","broken.","broker","broker,","broker.","brows","browser","bsd","bssid","bssid,","bssid=none,","bt","bt.connect(adv.mac)","bt.get_adv()","bt.resolve_adv_data(adv.data,","bt.start_scan(","bt_o.events()","bu","buf","buf)","buf):","buf,","buf.","buf:","buffer","buffer,","buffer.","bufsize.","bug","build","build/gpy/release/bootloader/bootload","build/gpy/release/gpy.bin_enc_0x10000","build/gpy/release/lib/partitions.bin_enc","built","builtin","burn","burn_efus","burn_key","burnt","bus,","bus.","bus:","buse","business.","but,","buttom","button","button)","button).","button,","button.","buttons.","buy","bw","bypass","byte","byte)","byte,","byte.","bytearray","bytearray(5)","bytearray(8)","bytearray(blocksize)","bytes([0x01,","bytes([0x10]))","bytes)","bytes).","bytes,","bytes.","bytes:","bytes_at()","c","c,","c.","c/c++","c:\\program","c]","ca","ca.pem","ca_cert","ca_certs='/flash/cert/ca.pem')","ca_certs='/flash/cert/ca.pem',","ca_certs=none)","ca_certs=none,","cabl","cable.","cable/wir","cables,","cach","calendar","calibr","call","call,","call.","callable()","callable.","callback","callback,","callback.","called,","called.","called:","calls:","came","can't","can(0,","can(mode=can.normal,","can.callback(handler=can_cb,","can.callback(trigger,","can.deinit()","can.events()","can.filter_list","can.filter_list,","can.filter_mask","can.filter_rang","can.filter_range,","can.format_both,","can.format_both.","can.format_ext,","can.format_std","can.format_std,","can.init(mode=can.normal,","can.norm","can.normal,","can.recv()","can.recv(timeout=0)","can.rx_fifo_not_empti","can.rx_fifo_not_empty,","can.rx_fifo_overrun","can.rx_fifo_overrun,","can.rx_fram","can.rx_frame,","can.send(id,","can.send(id=0x0020,","can.send(id=0x010,","can.send(id=0x012,","can.send(id=12,","can.silent,","can.silent.","can.soft_filter(can.filter_list,","can.soft_filter(can.filter_mask,","can.soft_filter(can.filter_range,","can.soft_filter(mode,","can.soft_filter(none)","can_cb(can_o):","can_o.recv())","cancel","canonname,","can't","capabilities.","capabl","capacit","capit","captur","card","card'","card)","card,","card.","care","carefulli","carefully:","carri","carrier","carrier'","carrier,","carrier=none)","carrier_duty_perc","carrier_freq_hz","carrier_level","case","case)","case).","case,","case.","cases,","cases.","cat","categori","categoris","catm1","caught","caught,","caus","cause.","cb","cdc","ce","cell","cell)","cells,","cellular","centr","central","centuri","cert","cert_req","cert_reqs=cert_none,","cert_reqs=ssl.cert_required,","certain","certfil","certfile='/flash/cert/client.crt')","certfile=none,","certif","certificate\"","certificate,","certificate.","certificate.pdf)","certificates,","certifl","chain","chaining.","chanc","chang","change.","changed.","changes.","changes:","channel","channel,","channel.","channel:","channel=1,","channel=6,","channel=7,","channels,","chapter","char","char.read()))","char1_cb_handler(chr):","char1_read_count","char2_cb","char2_read_count","charact","character)","character.","characterist","characteristic,","characteristic.","characteristic.callback(trigger=none,","characteristic.events()","characteristic.instance()","characteristic.properties()","characteristic.read()","characteristic.uuid()","characteristic.value()","characteristic.value(123)","characteristic.value([value])","characteristic.write(b'x0f')","characteristic.write(value)","characteristics,","characteristics.","characters,","characters.","charg","charge,","charger","charger.","chars:","chart","chart).","check","checkbox","checking.","checkout","checksum.","chg","chip","chip_id","choic","choice.","choos","chose","chosen","chosen.","chr()","chr.events()","chr1","chr2.callback(trigger=bluetooth.char_read_event,","chrono","chrono.read()","chrono.read_ms()","chrono.read_us()","chrono.reset()","chrono.start()","chrono.stop()","chrono:","chronomet","chronometer.","chunk","cid","cid=1)","cid=1.","cid=3.","cipher","cipher.","cipher.decrypt(msg[16:])","cipher.encrypt(b'attack","ciphertext","circle'","circumfer","circumstances.","claim","claim,","clariti","class","class,","class.","class.html).","class:","classes,","classes.","classes/funct","classic","class'","claus","clean","clear","cli","cli.","cli.ex","click","click,","client","client,","client.","client.check_msg()","client.connect()","client.publish(topic=\"youraccount/feeds/lights\",","client.set_callback(sub_cb)","client.subscribe(topic=\"youraccount/feeds/lights\")","client_id","clients,","climates),","clipboard.","clk,","clk,p11","clock","clock()","clock:","close","close()","closed.","cloud","cloud.","clutter","cmath","cmath.cos(z)","cmath.e:","cmath.exp(z)","cmath.log(z)","cmath.log10(z)","cmath.phase(z)","cmath.pi:","cmath.polar(z)","cmath.rect(r,","cmath.sin(z)","cmath.sqrt(z)","cmd","cmd_matchrom","cmd_readrom","cmd_searchrom","cmd_skiprom","code","code).","code,","code.","code:","codes.","codes:","coding,","coding_r","coding_rate=lora.coding_4_5,","coil","coil_quantity)","coil_quantity=100","coil_statu","coil_status))","coils,","cold","collect","collected,","collection.","collis","collision,","colombia","color","color,","colour","colour.","colours.","com","com1","com4)","com6","combin","combinations;","combined):","come","comma","command","command):","command,","command.","command:","commands,","commands.","commands:","comment","common","commonli","commun","communication.","compani","compar","comparison.","comparisons.","compat","compatibility.","compens","compil","compile()","complement","complementari","complet","complete,","complete.","completed!","completed,","completed.","completely.","completes.","completion:","complex","compliant","compon","component.","components:","compos","comprehens","comput","computer)","computer);","computer,","computer.","computer:","concept","concis","condit","conditions:","config","config)","config.aws_client_cert)","config.aws_port)","config.aws_private_key,","config.last_will_msg,","config.pi","config.py)","config=['dhcp'","configtuple])","configur","configurable,","configuration.","configuration:","configured.","confirm","conform","confus","congratul","conn","conn.disconnect()","conn.services()","conn_cb","conn_disconn_timeout","connecor.","connect","connect,","connect.","connected\")","connected),","connected).","connected,","connected.","connecting,","connection,","connection.","connection.disconnect()","connection.in","connection.isconnected()","connection.services()","connections),","connections.","connectivity,","connectivity.","connector","connector)","connector,","connector.","consecut","consid","consider","consist","consol","console,","console.","const","const(0x33)","const(0x55)","const(0xcc)","const(0xf0)","const(120)","const(123)","const(2","const(4096)","const_i","const_x","constant","constantli","constants.","constrained,","construct","construct.","constructor","constructor.","consum","consumpt","consumption.","contact","contain","contain.","contained.","contains:","content","content.","contents,","contents/resources,","contents]","context.","contigu","continu","continuation`","continuo","contract","contract,","contract.","contribut","control","control)","control.","controller,","controller.","controllers.","conveni","convers","convert","cooki","coord","coordin","copi","copied/upload","copy,","copy/past","copy/writ","copyright","core","corner","corner.","correct","correct,","correctli","correctly,","correctly.","correspond","cosin","count","count).","count_per_c","count_remain","count_remain)","counter","counter,","counters,","countri","coupl","courtesi","cover","coverag","cpu","cpu,","cpython","cpython.","cpython'","cr","crash","crc","crc8(self,","creat","create.","create/regist","created,","created.","creation.","credenti","credentials.","credentials:","critic","crosswind","crucial","crypto","crypto.getrandbits()","crypto.getrandbits(128)","crypto.getrandbits(bits)","crypto1","cryptograph","cryptographi","cs","ct","ctr","ctrl","ctrl+d","ctrl_c_on_connect","cts))","cts.","ctype","current","current.","current_v","currently,","currently:","cursor","cursor.","custom","customcallback(client,","customcallback)","customis","customisable,","customshadowcallback_delete(payload,","customshadowcallback_delta(payload,","customshadowcallback_update(payload,","customshadowcallback_update,","cut","cycl","cycle.","cycles.","d","d,","d.","d.setvariable('presence:livingroom','1')","d0dc708","d]","dac","dac.deinit()","dac.init()","dac.tone(frequency,","dac.write(0.5)","dac.write(value)","dac_ton","dac_tone.tone(1000,","damag","damaged.","damien","darwin","dash","dashboard","dashboard!","dashboard'","dashboard.","dashboard;","dat0,","data","data)","data):","data,","data.","data;","data=b'123',","data=bytes([0x01,","data=bytes([1,","data=none,","data[6]","data[7]","data[i]","data_typ","data_type)","database.","datagram","datasheet","datasheets.","datatyp","date","date,","date/tim","date/time.","datetim","datetime.","dawn')","day[,","days),","db","dbm).","dbm.","dc","de","deal","debian:","debug","debug=false)","debug`","debuggin","decid","decision.","declar","decompos","decreas","decrypt","decryption.","deep","deepsleep","deepsleep()","deepsleep.","deepsleep.disable_pullups(pins)","deepsleep.disable_wake_on_fall(pins)","deepsleep.disable_wake_on_raise(pins)","deepsleep.enable_auto_poweroff()","deepsleep.enable_pullups(pins)","deepsleep.enable_wake_on_fall(pins)","deepsleep.enable_wake_on_raise(pins)","deepsleep.get_wake_status()","deepsleep.go_to_sleep(seconds)","deepsleep.hw_reset()","deepsleep.pin_wake:","deepsleep.power_on_wake:","deepsleep.set_min_voltage_limit(value)","deepsleep.timer_wake:","def","default","default)","default).","default,","default.","defaults.","defin","define.","defined,","defines).","definit","definitions,","definitions.","degre","degrees.","deinit()","deinitialis","delay","delays.","delet","delete:","deliv","delta","demo","demo,","demonstr","denot","depend","dependent,","depict","deploy","depth","dereferenc","dereference,","describ","descript","descriptor","descriptor,","design","desir","dest","dest)","destin","destroy","detach","detail","details.","detect","detected,","detected.","detection)","determin","dev","dev_addr","dev_eui","develop","development.","deveui)","devic","device!","device\"","device\")","device'","device)","device),","device).","device):","device,","device.","device...","device:","device;","device_class","device_class=lora.class_a)","device_id","device_id):","device_id,","deviceid,","devices).","devices,","devices.","devices:","deviceshadowhandl","deviceshadowhandler.shadowdelete(customshadowcallback_delete,","deviceshadowhandler.shadowregisterdeltacallback(customshadowcallback_delta)","deviceshadowhandler.shadowupdate(jsonpayload,","devicetoken","devkit","dfu","dfu,","dfuidle,","dhcp","dht11/dht22/am2302","diagram","dialog","dialout","diamet","dict","dictat","dictionari","dictionaries,","dictionary),","diff","diff)","diff):","differ","differences.","different,","differently.","difficult","digest","digest.bin","digest.bin_enc","digit","dio","dir()","direct","directional,","directions).","directli","directly,","directly.","directori","directories.","directory).","directory.","directory:","disabl","disable_irq","disable_irq()","disabled)","disabled,","disabled.","discharges.","disconnect","disconnected\")","disconnected.","discontinued,","discov","discret","discuss","disengag","display","display.","distinguish","distribut","distribute,","distributor","divmod()","dns)","dns_server)","dns_server).","do","do.","do:","doc","docs),","docs.","document","document).","documentation,","documentation.","does.","doesn't","doesn't","doing.","domain","domain,","domoticz","domoticz(\"\",","domoticz:","don't","done","done!","done,","done.","don't","dot","doubl","doubt","down","down.","downgrad","downlink","downlink_frequency_hz)","download","dq0054e","dr:","dr=0,","dr=none)","dr_max)","dr_max:","dr_max=6)","dr_min,","dr_min:","dr_min=5,","drag","drain","draining_freq","draw","drawbacks.","dri","drive","drive'","drive','chris':'3236","drive','joe':'1301","driven","driver","driver,","driver.","drivers,","drivers.","drivers:","drivers;","drop","dropdown","ds","ds.enable_pullups('p17')","ds.enable_pullups(['p17',","ds.enable_wake_on_fall('p17')","ds.enable_wake_on_fall(['p17',","ds.get_wake_status()","ds.go_to_sleep(60)","ds18b20","ds18x20","ds18x20(ow)","dual","due","dup","duplex","duplic","durat","duration):","duration,","duration.","duration[i]","dure","during:","duti","duty,","duty_cycl","duty_cycle=0.5)","e","e)","e.g.","e.g.:","e.g:","e.ssid","e:","each","eap","earlier","earlier,","eas","easi","easier.","easiest","easili","easy.","echo","eco","ecosystem","ed","edg","edge.","edit","editor","editor'","editors,","effect","effect.","effectively,","effici","efficient.","effort","efus","efuse,","efuses.","either:","eitherbluetooth.int_ant,","elaps","elapsed.","elapses,","elapses.","electr","electron","element","elements,","elements.","elements:","elev","elif","else:","elsewhere.","email","embed","emerg","empow","empti","empty,","emul","enabl","enable.","enable_auto_poweroff","enable_irq","enable_irq(i)","enable_pul","enable_pull)","enabled,","enabled.","enabling,","encapsul","encod","encoding,","encrypt","encrypt_key=flash_encryption_key.bin","encrypted,","encrypted.","encrypted;","encryption)","encryption.","end","end.","end=\"\")","endian","endianness,","endpoint","ends,","energi","enforced).","enforced.","enough.","ensur","enter","enter,","enterpris","entir","entri","enumerate()","environ","environment:","environments,","eof.","epoch","epoch,","epoch:","equal","equival","eras","erase_al","erase_f","erase_region","errat","error","error,","errors,","esd","esp32","esp32'","esp32')","esp32).","esp32,","espbaud**","espbaud.","espport","espport**","espressif","espressif'","esptool","esptool.","essenti","est","establish","etc)","etc).","etc.","etc.)","etc.).","etc.);","eu","eu868","eu868,","eui","eui,","eui.","europ","europe,","eval()","evalu","even","event","event,","event.","eventmask","eventmask)","eventmask])","events.","events:","everyth","everything'","exact","exactitud","exactli","exactly.","exampl","example)","example,","example.","example:","example;","examples,","examples.","examples/docs)","examples:","exce","exceeded.","excel","except","except:","exception,","exception.","exception:","exchang","exclus","exclusive;","exec()","execut","executed,","executed.","executes\")","execution,","execution.","execution...","exemple,","exist","existence).","exists)","exists,","exists.","exit","exits.","exp","exp(x)","exp)","expand","expans","expect","expected,","expected.","experi","experienc","expir","expire)","expired,","explain","explan","explicit","explicitli","explicitly,","explor","exponent.","exponenti","expos","express","expression,","expression.","expressions).","extend","extended)","extended=false)","extended=true)","extens","extension:","extern","externally.","extnt","extra","extract","extract_public_key","extrapref","extraprefs]","f","f,","f.close()","f.readall()","f.readinto(buffer)","f.write('test","f014","f:","facil","fact","facto'","factor","factor,","factor.","factori","factory,","factory.","fail","fail,","fail.","failed\")","failed,","fails,","fails.","failur","failure,","failure.","fall","fallback","falling])","fals","false)","false).","false,","false.","famili","familiar","familiaris","family,","far","fashion.","fast","faster","faster.","fat","fat16","fat16/32","fat32.","favourit","fb_bit","fcc","featur","feature,","feature.","feature;","features,","features.","features/functionality.","features:","februari","fed","fedora:","feed","feedback.","feel","femal","fetch","few","ffi","fi","fi/bt","field","field).","field.","fields.","fields:","fifo","fifo.","file","file,","file.","file:","file=sys.stdout)","file]","filenam","files,","files.","files\\pycom\\pycom","filesystem","filesystems.","filezilla","filezilla,","fill","filter","filter()","filter_list","filter_list)","filtering.","filters,","final","finally,","find","finish","finished,","finished.","finite.","fipi","fipy)","fipy,","fipy.","fipy:","fireftp","firmare_version.bin,","firmli","firmwar","firmware,","firmware.","firmware:","firmware;","firmware_1.0.0.bin","firmware_1.0.1.bin","first","first).","first,","first.","firstbit","firstbit=spi.msb)","firstbit=spi.msb,","firstli","fit","fix","fix.","fixed,","flag","flag.","flag;","flags.","flash","flash!","flash,","flash.","flash/pybytes_config.json","flash:","flash_crypt_cnt","flash_crypt_config","flash_encrypt","flash_encryption_key.bin","flash_freq","flash_mod","flash_siz","flat","flavours:","fleet;","float","float)","float).","float32).","floats,","flow","flushed).","fmt","fmt.","folder","folder).","folder,","folder.","folder:","follow","following,","following:","follows:","forc","forev","forever.","forever...)","form","form.","form:","format","format(s)","format)","format).","format,","format.","formats.","formed.","former","forms.","forum","forum?","forward","forwarder\"","forwarder.","found","found!')","found,","found.","four","fp","fraction","frame","frame.","frame_format","frame_format=can.format_std,","frames,","free","free.","freeli","freq","frequenc","frequency)","frequency,","frequency.","frequency:","frequency=","frequency=5000)","frequency=868000000)","frequency=868000000,","frequency=912000000)","frequency=none)","frequent","fro","from,","from.","from/to","frozenset","frozenset([e.ssid","frozenset([key","fs,","fs1,","fsk","fsk,","fsk.","fsm","ftdi","ftdi]","ftdi`","ftp","ftp.","ftp:","ftp://192.168.4.1","ftp>","fulfilled.","full","full.","fulli","function","function,","function.","functional,","functionality,","functionality.","functions,","functions.","functions/assignments/etc.","functions/class","furnish","further","futur","future,","fwtool","fwtool.","g","g01","g01)","g01),","g01,","g01.","g01:","g1d8b5e5","g23","gain","gain:","gamma","gap","gap.","garbag","gate","gateway","gateway,","gateway.","gateways.","gather","gatt","gattccharacterist","gattcconnect","gattcconnection.","gattcservic","gattscharacterist","gattscharacteristic.","gattsservic","gb.","gc","gc.collect()","gc.collect().","gc.disable()","gc.enable()","gc.mem_alloc()","gc.mem_free()","gc.mem_free()))","gener","generate_flash_encryption_key","generate_signing_key","generated,","generated:","generator.","gentl","geograph","geoloc","geolocation.","george,","gerber","get","get/set","get_adv()","getattr()","gil","github","github.","give","given","given,","given.","global","globals()","glonass","glonass)","gmtime()","gnd","gnd.","gnss)","gnu","go","go_to_sleep()","goe","goldleaf","gone","good","googl","google'","gp","gpi","gpi08","gpi09","gpio","gpio.","gpio16","gpio21","gpio=\"p20\",","gpio=\"p21\",","gpio_list).","gpl","gps,","gpy,","gpy.","gpy.bin_enc_0x10000","gpy.bin_enc_0x1a0000","gpy/fipi","gpy:","grant","granted,","great","greater","green","green.","grid","grid.","ground","group","group.","groups,","groups.","grow","guarante","gui","guid","guide,","guide.","gyp","h","h,","h]","half","halt","hand","hand,","handl","handler","handler)","handler.","handler:","handler=char2_cb_handler)","handler=conn_cb)","handler=lora_cb)","handler=none,","handling.","hang","happen","happens,","happens.","harald","hard","hardwar","hardware,","has_joined()","hasattr()","hash","hash()","hash,","hash.","hash.digest()","hash.hexdigest()","hash.update(data)","hasher","hasn't","have","haven't","haven't,","header","header)","header).","header,","headers,","heap","heap.","heap_lock()","heap_unlock()","heart","heartbeat","heartbeat.","held","held,","hello","help","help(machine)","help.","help`","here","here\"","here'","here)","here).","here,","here.","here...","here:","herebi","hertz.","hex","hex()","hexadecim","hexidecim","hexlify)","hidden","hidden,","hidden=false)","hide","high","high!\")","high,","higher","higher)","higher.","highest","highli","hillview","hint:","his/her","histori","history:","hold","hold.","hold_tim","hold_time_sec","hold_time_sec:","holder","holds.","hole,","home","homebrew:","hong","host","host/port","hour","hour,","hour[,","how.","however,","http","http/1.0\\r\\n\\r\\n\")","http/1.0\\r\\nhost:","http/1.1\\r\\nhost:","http://127.0.0.1:8000/manifest.json?current_ver=1.0.0","http://sourceforge.net/p/dfu","https://backend.sigfox.com/activ","https://backend.sigfox.com/auth/login","https://docs.pycom.io/chapter/advance/cli.html","https://github.com/pycom/pycom","https://software.pycom.io/downloads/sequans2.html","https://www.pycom.io/opensource/licens","human","humid","humidity.","hundr","hyperbol","hz","hz.","i))","i,","i.e.","i.e.:","i/o","i2c","i2c(0)","i2c(0,","i2c,","i2c.","i2c.deinit()","i2c.init()","i2c.init(i2c.master)","i2c.init(i2c.master,","i2c.init(mode,","i2c.mast","i2c.master()","i2c.master)","i2c.master,","i2c.master:","i2c.readfrom(0x42,","i2c.readfrom(addr,","i2c.readfrom_into(addr,","i2c.readfrom_mem(0x42,","i2c.readfrom_mem(addr,","i2c.readfrom_mem_into(addr,","i2c.scan()","i2c.writeto(0x42,","i2c.writeto(addr,","i2c.writeto(addr=0x42,","i2c.writeto_mem(0x42,","i2c.writeto_mem(addr,","i2c;","ibeacon","ibeacons).","iccid","icon","id","id()","id)","id).","id):","id,","id.","id=0x12","idea","ideal","ident","identifi","identifier.","identity='myidentity',","identity=none)","idl","idle,","idle.","idx,","if,","ified\"","ignor","ignored.","illustr","imag","image.","images,","imagin","imei","imei.","immedi","immediate.","immediately,","immediately.","immutable,","implement","implementation),","implementation.","implemented,","implemented.","implicit.","implied,","import","important:","importantly,","importing/us","improp","improv","in,","in.","inact","inc(index,","inc.","incas","includ","include:","inclus","incom","inconsist","incorrect","increas","increase,","increment","indefinit","indefinitely.","indent","indentation,","independ","index","index.","index:","indic","individu","indoor","infinit","infinite.","infinity.","info","info)","info).","info,","inform","information.","informational.","information”","infrar","infrequ","inherit","init","init()","initalis","initi","initialis","initialisation.","initialisation.:","initialised,","initialised.","inod","inp","input","input()","input,","input.","input/output).","input_quantity)","input_quantity=100","input_statu","input_status))","inputs).","insert","insid","instal","install.","installation.","installation:","installed.","instanc","instance).","instance,","instance.","instance:","instanti","instantiated.","instantiation.","instead","instead,","instead.","instruct","instruction:","instructions,","instructions.","int","integ","integer,","integer.","integers.","integr","integration.","integration:","integrity.","intellig","intend","intent","interact","interest","interfac","interface\"","interface)","interface,","interface.","interface...","interfaces.","interfer","intermedi","intern","internal).","internal/extern","internet","interog","interpret","interpreter.","interrupt","interrupt).","interrupt.","interrupts,","interrupts.","interrupts;","interv","interval,","interval.","intervals,","introduc","introduct","ints.","invalid","invent!","invers","inversion.","io","ion/li","iot","iot,","iot.","iot:","ip","ip,","ip67","ipv4","ipv4_address","ipv4_address,","iq","irq","irrepar","irrevers","is,","is:","isinstance()","isn't","iso14443a,","isprimari","isprimary=true)","isprimary=true,","issu","issubclass()","issue.","issues,","is”,","it!","it'","it)","it,","it.","it:","item","items,","items.","iter","iter()","iterable.","iterable])","itself","itself.","it'","iv","iv)","iv,","jan","japan.","join","joined.","joined...')","json","json,","json.loads(payload)","json.pi","jsonpayload","jst","jump","jumper","jumpers,","kbp","keen","keep","kept","key","key'))","key).","key,","key.","key.bin","key.bin)","key.bin,","key_typ","key_type,","keyboard","keyboard.","keyboardinterrupt","keyfil","keyfile='/flash/cert/client.key',","keyfile=none,","keys,","keyword","keyword,","keyword.","khz","khz.","kib)","kind","kind,","kit","know","known","known_net","known_nets[net_to_use]","known_nets])","known_nets_nam","known_nets_names)","kong,","kwarg","kwargs])","l","l)","l,","l01","l01'","l01,","l01/w01","l01:","l04","l04,","l04:","l76","l76.coordinates()","l76gnss","l76gnss(py,","l76gnss(pytrack","l76gnss.","l76gnss.coordinates(debug","l_rom","l_rom,","l_rom:","lab","label","lack","lane'}","languag","language.","lap","lap\"","lap)","lap))","larg","last","last).","last_trigg","last_will_msg","last_will_top","later","later,","latest","latest.","latitud","latitude.","latter","layer","layer\")","layers.","layers:","layout","layout/gitbook/assets/l01","layout.pdf)","layout_type=native)","layouts,","lead","learn","leav","led","led(0)","led(1)","led).","led.","led.toggle()","left","legaci","len","len()","len(buf)","len(msg),","len)","length","length)","length.","less","less)","let","let'","letter,","let'","level","level,","level.","li","liability,","liabl","lib","lib)","lib.","lib_a.pi","librari","libraries)","libraries,","libraries.","libraries/tree/master/lib/sqnsupgrad","library\"","library,","library.","library;","library'","libusb","libusbk","licenc","licens","life","life,","life.","light","light_sensor","light_sensor.read()","light_sensor.read())","lights.","lightweight","like:","limit","limitations).","limitations,","limited.","line","line).","line,","line.","lines:","ling","link","link.","links.","linux","linux,","linux.","linux/macos)","linux:","lipo","lis2hh12","lis2hh12()","lis2hh12(pysens","lis2hh12(pytrack","lis2hh12)","lis2hh12.","lis2hh12.acceleration()","lis2hh12.pi","lis2hh12.pitch()","lis2hh12.roll()","list","list(net","list,","list.","listen","lists,","lite","littl","live","llvm","load","load)","local","local_tim","locals()","localtime()","localtime.","locat","located.","location.","location=20","lock","lock.","lock.acquire(waitflag=1,","lock.locked()","lock.release()","lock:","locks:","log","log,","logarithm","logic","login","login.","login=('micro',","long","long.","longer","longer.","longest","longitud","longitude/latitude,","look","lookup","loop","loop\")","loop)","loop,","loop/non","loopcount","loops,","loops.","loos","loosevers","lopi","lopy!","lopy!\")","lopy'","lopy,","lopy.","lopy4","lopy4,","lopy4.","lopy4:","lopy:","lopys.","lopy'","lora","lora()","lora(mode=lora.lora,","lora(mode=lora.lorawan)","lora(mode=lora.lorawan,","lora)","lora,","lora.","lora.abp","lora.abp.","lora.add_channel","lora.add_channel(index,","lora.add_channel(index=0,","lora.always_on,","lora.as923","lora.as923,","lora.au915","lora.au915,","lora.bandwidth()","lora.bandwidth([bandwidth])","lora.bandwidth(lora.bw_125khz)","lora.bw_125khz","lora.bw_125khz,","lora.bw_250khz","lora.bw_250khz,","lora.bw_250khz.","lora.bw_500khz","lora.bw_500khz.","lora.callback(trigger,","lora.callback(trigger=(lora.rx_packet_ev","lora.class_a","lora.class_a,","lora.class_c","lora.class_c.","lora.coding_4_5","lora.coding_4_5,","lora.coding_4_6","lora.coding_4_6,","lora.coding_4_7","lora.coding_4_7,","lora.coding_4_8","lora.coding_4_8.","lora.coding_rate()","lora.coding_rate([coding_rate])","lora.coding_rate(lora.coding_4_5)","lora.eu868","lora.eu868,","lora.events()","lora.events().","lora.frequency()","lora.frequency(868000000)","lora.frequency([frequency])","lora.has_joined()","lora.has_joined().","lora.has_joined():","lora.init(mode,","lora.init(mode=lora.lora,","lora.init(mode=lora.lorawan)","lora.init(mode=lora.lorawan,","lora.ischannel_free(","lora.ischannel_free(rssi_threshold)","lora.join(activation,","lora.join(activation=lora.abp,","lora.join(activation=lora.otaa,","lora.lora","lora.lora,","lora.lorawan","lora.lorawan.","lora.mac()","lora.mac().to","lora.nvram_erase()","lora.nvram_restore()","lora.nvram_save()","lora.otaa","lora.otaa,","lora.power_mode([power_mode])","lora.preamble()","lora.preamble([preamble])","lora.preamble(lora.coding_4_5)","lora.remove_channel()","lora.remove_channel(index)","lora.rx_packet_ev","lora.rx_packet_event,","lora.rx_packet_event:","lora.set_battery_level(127)","lora.set_battery_level(level)","lora.sf()","lora.sf(7)","lora.sf([sf])","lora.sleep","lora.sleep.","lora.sleep:","lora.stats()","lora.tx_failed_ev","lora.tx_onli","lora.tx_only,","lora.tx_packet_ev","lora.tx_packet_event),","lora.tx_packet_event,","lora.tx_packet_event:","lora.us915","lora.us915.","lora/sigfox","lora_cb(lora):","lora_confirm_format","lora_pkg_format","lora_region","lora_sock","lora_sock.recv(256)","lora_sock.recv(512)","lora_sock.recv(64)","lora_sock.send(ack_pkg)","lora_sock.send(msg)","lora_sock.send(pkg)","lora_sock.setblocking(false)","loraeu868.","lorawan","lorawan.","lose","lot","low","low.","lower","lower,","lowest","lpwan","lsusb","lt","lte","lte()","lte(carrier=\"verizon\")","lte).","lte.","lte.attach()","lte.attach(*,","lte.attach(band=13)","lte.connect()","lte.connect(*,","lte.connect(cid=3)","lte.deinit()","lte.dettach()","lte.disconnect()","lte.iccid()","lte.imei()","lte.init(*,","lte.isattached()","lte.isattached())","lte.isattached():","lte.isconnected()","lte.isconnected():","lte.reset()","lte.send_at_cmd('at!=\"addscanband","lte.send_at_cmd('at!=\"clearscanconfig\"')","lte.send_at_cmd('at!=\"disablelog","lte.send_at_cmd('at+cereg?')","lte.send_at_cmd('at+cfun=0')","lte.send_at_cmd('at+cfun=1')","lte.send_at_cmd('at+cgdcont=1,\"ip\",\"nb.inetd.gdsp\"')","lte.send_at_cmd('at+cgsn=1')","lte.send_at_cmd(cmd)","lte.send_at_cmd(cmd).split('\\r\\n')","ltr","ltr329als01","ltr329als01(py)","ltr329als01(pysens","ltr329als01.light()","ltr329als01.pi","lux","lux.","m","m']","m/nb","m1","m1,","m1/nb","m1:","m1nb","mac","mac_addr","machin","machine,","machine.adc()","machine.adc(id=0)","machine.brown_out_reset","machine.can(bus=0,","machine.dac('p21')","machine.dac('p22')","machine.dac(pin)","machine.deepsleep([time_ms])","machine.deepsleep_reset,","machine.disable_irq","machine.disable_irq()","machine.enable_irq","machine.enable_irq([state])","machine.freq()","machine.hard_reset,","machine.i2c(bus,","machine.idle()","machine.info()","machine.main(filename)","machine.pin(id,","machine.pin_deepsleep_wakeup(pins,","machine.pin_wake,","machine.pwm(timer,","machine.pwron_reset,","machine.pwron_wake,","machine.remaining_sleep_time()","machine.reset()","machine.reset_cause()","machine.rmt(channel,...)","machine.rmt(channel=2)","machine.rmt(channel=2,","machine.rmt(channel=3)","machine.rmt(channel=3,","machine.rng()","machine.rtc()","machine.rtc().datetime(tuple)","machine.rtc(id=0,","machine.rtc_wake,","machine.sd(id,","machine.soft_reset,","machine.soft_reset:","machine.spi(id,","machine.uart(0,","machine.uart(bus,","machine.ulp_wak","machine.unique_id()","machine.wake_reason()","machine.wakeup_all_low","machine.wakeup_all_low,","machine.wakeup_any_high","machine.wakeup_any_high.","machine.wdt(id=0,","machine.wdt_reset,","machine='gpi","machines,","maco","macos,","macos/linux","macos/linux:","macos:","macports:","macro","made","made.","magic","main","main.pi","main.py)","main.py.","main.py;","mainli","maintain","major","make","makefil","makefile()","makefile().","male","manag","manager'","manager.","mandat","mandatori","mandatory.","mani","manifest","manifest.json.","manipul","manner","mantissa","manual","manual,","manually.","manufactur","manufacturer_data","manufacturer_data=\"lopy_v1\")","manufacturer_data=none,","map","map()","mark","mask","mask).","master","master,","master.","master/slav","master:","match","match()","match,","match.group([index])","math","math.acos(x)","math.acosh(x)","math.asin(x)","math.asinh(x)","math.atan(x)","math.atan2(y,","math.atanh(x)","math.ceil(x)","math.copysign(x,","math.cos(x)","math.cosh(x)","math.degrees(x)","math.e:","math.erf(x)","math.erfc(x)","math.exp(x)","math.expm1(x)","math.fabs(x)","math.floor(x)","math.fmod(x,","math.frexp(x)","math.gamma(x)","math.isfinite(x)","math.isinf(x)","math.isnan(x)","math.ldexp(x,","math.lgamma(x)","math.log(x)","math.log10(x)","math.log2(x)","math.modf(x)","math.pi:","math.pow(x,","math.radians(x)","math.sin(x)","math.sinh(x)","math.sqrt(x)","math.tan(x)","math.tanh(x)","math.trunc(x)","mathemat","max","max()","max_split=","max_time_wait","maximum","maximum.","mbr","mcu","mcu/soc.","mcu_registers.peripheral_a.register1,","md5","mday","mday,","mean","meaning;","means:","meant","measur","measurement,","measurement_tim","measurement_time:","mechan","mechanism.","medium","memaddr,","memaddr.","member","memori","memory,","memory.","memoryerror","memoryview","memoryview(buffer)","memory'","mention","menu","merchantability,","merge,","mesh","messag","message'","message):","message,","message,\"done!\"","message.","message:","messages,","messages.","metadata","meter","meter.","method","method()","method)","method,","method.","method:","methodolog","methods,","methods.","methods:","mexico","mf","mfg_data","mfg_data:","mfrc630","mfrc630(py)","mfrc630(pyscan=none,","mfrc630.format_block(block,","mfrc630.mfrc630_cmd_idle()","mfrc630.mfrc630_cmd_init()","mfrc630.mfrc630_cmd_load_key(key)","mfrc630.mfrc630_cmd_load_key(key).","mfrc630.mfrc630_cmd_reset()","mfrc630.mfrc630_format_block(data,","mfrc630.mfrc630_iso14443a_select(uid)","mfrc630.mfrc630_iso14443a_wupa_reqa(instruction)","mfrc630.mfrc630_mf_auth(uid,","mfrc630.mfrc630_mf_deauth()","mfrc630.mfrc630_mf_read_block(block_address,","mfrc630.mfrc630_print_block(data,","mfrc630.mpi","mfrc630.print_debug(msg)","mfrc63002hn,","mfrc630_format_block","mfrc630_iso14443_cmd_reqa","mfrc630_iso14443_cmd_wupa,","mfrc630_mf_auth_key_b)","mfrc630_mf_deauth()","mhz","mhz)","mhz.","micro","micro),","micro.","microchip","micropygp","micropython","micropython,","micropython.","micropython.alloc_emergency_exception_buf(size)","micropython.const(expr)","micropython.heap_lock()","micropython.heap_unlock()","micropython.kbd_intr(chr)","micropython.mem_info([verbose])","micropython.opt_level([level])","micropython.qstr_info([verbose])","micropython.stack_use()","micropython:","micropython;","micropyton","microsd","microsecond","microsecond[,","microseconds,","microseconds.","microsoft","microsoft'","mifar","milisecond","millisecond","millisecond).","milliseconds)","milliseconds,","milliseconds.","millivolts)","millivolts,","min","min()","mind","mind,","minicom","minim","minimis","minimum","minimum.","minor","minor,","minut","minute,","minute[,","minutes,","mircopython","mirror","miscellan","miso","miso)","miso))","miso).","miso.","mistake,","mit","mobil","mobility.","mod","modbu","modbus_obj.read_coils(slave_addr,","modbus_obj.read_discrete_inputs(slave_addr,","modbus_obj.read_holding_registers(slave_addr,","modbus_obj.read_input_registers(slave_addr,","modbus_obj.write_multiple_coils(slave_addr,","modbus_obj.write_multiple_registers(slave_addr,","modbus_obj.write_single_coil(slave_addr,","modbus_obj.write_single_register(slave_addr,","mode","mode\")","mode)","mode).","mode,","mode.","mode...","mode:","mode;","mode=bluetooth.ble,","mode=can.normal,","mode=pin.in,","mode=pin.open_drain)","mode=pin.out)","mode=pin.out)(true)","mode=pin.out,","mode=spi.master,","model","modem","modem,","modem.","modes.","modes:","modes;","mode'","mode'.","modif","modifi","modification.","modified;","modify,","modul","modulate,","modulation.","module'","module)","module).","module):","module,","module.","module/accessori","module:","modules,","modules.","modules:","module'","modulu","moment.","mon","monarch","monitoring,","monitoring.","month","month,","more","more)","more,","more:","mosi","mosi,","motion","mount","mount(sd,","mount_point,","mounted,","mounted.","move","mpl3115a2","mpl3115a2(pysens","mpl3115a2.","mpl3115a2.altitude()","mpl3115a2.pressure()","mpl3115a2.temperature()","mqtt","mqtt.","mqtt]","mqtt_oper_timeout","mqttclient","mqttclient(\"device_id\",","mqttserviceaddress","ms","ms)","ms).","ms,","ms.","msg","msg)","msg))","msg):","msg=\"off\")","msg=\"on\")","msg[:16])","much","multipl","multipli","mutabl","mutex","mv","my_struct.substruct1.field1.","n","name","name\"","name,","name.","name=none,","names.","nano","narrow","nativ","natur","navig","nb","nb1","nbr_char","nbr_chars=1,","nbyte","nbytes)","nbytes,","nbytes])","near","nearest","necessari","necessarili","necessary,","necessary.","need","needed)","needed.","needs:","neg","negoti","negotiation...","nest","nested,","net","net.ssid","net_properti","net_properties:","net_properties['pwd']","net_to_us","net_to_use[0]","net_to_use][0]","nets\")","nets:","network","network,","network.","network.bluetooth(id=0,","network.lora(id=0,","network.lte(id=0,","network.serv","network.server()","network.server(id,","network.sigfox(id=0,","network.wlan(id=0,","network.wlan(mode=network.wlan.sta)","network.wlan.","networking.","networks.","networks:","never","new","new)","new,","new:","new_lib.pi","new_path)","newer","newer)","newli","newlin","next","next()","next_diff","nfc","nfc.mfrc630_cmd_init()","nfc.mfrc630_cmd_reset()","nist.","no_reset","node","nodej","nodejs.","nodename='gpy',","noexit","noexit`","nois","non","none","none)","none).","none):","none,","none.","noninfringement.","nonneg","nonzero","nonzero,","norm.","normal","normal,","normal.","normalis","normally,","not).","not.","notabl","notat","notation:","note","note,","note:","notes.","noth","notic","notif","notifi","notifications:","now","now,","ntp","ntp_sync","number","number,","number.","number1","number2","number2):","number:","number;","numbers.","numbers.\"","numer","nut.","nutshell,","nv","nvm","nvm).","nvram","nvram_sav","nvs,","nvs:","nwk_swkey","nwk_swkey,","nwpref","nwprefs]","nxp","obj","obj.","object","object)","object).","object,","object.","object;","objects.","object'","obligatori","obscur","obtain","obtained.","obvious","occupi","occur","occur,","occurs,","occurs.","oct()","oem","of.","of:","off\")","off.","off/on","off/on)","offend","offer","offic","offici","offline_queue_s","offset","offset,","offset.","offset=0)","often),","ohm","ok","ok.","old","older","oman","on","on\")","on),","on,","on.","on_the_fli","onboard","onc","once,","one,","one.","onewir","onewire(pin('p10'))","onewire:","ongo","only)","only),","only,","only.","onto","onward","onward,","open","open('/sd/gp","open('/sd/test.txt',","open()","open(appimg,","open)","open,","open.","open_drain","open_on_start","opened.","opened:","openmoko","oper","operations\".","operations')","operations).","operations.","operator,","opposit","optim","optimis","option","option,","option.","option;","optional.","options,","options:","optname,","or,","orang","ord()","order","order).","order:","ored):","organis","organise.","orient","origin","original_auth","original_ssid","os","os,","os.dupterm(uart)","os.listdir('/sd')","os.mkfs('/flash')","os.mkfs(sd)","os.mount(sd,","os.uname()","os/rto","oscil","ota","ota\")","ota.connect()","ota.update()","ota_0","ota_0,","ota_finish","ota_finish()","ota_finish().","ota_start()","ota_start(),","ota_start,","ota_write(buffer),","ota_write(mv[:chunk])","ota_write,","otaa","otadata,","other","other);","other,","others,","otherwis","otherwise,","otherwise.","otherwise:","ourselv","out","out!\")","out.","outdoor","outlin","outperform","output","output,","output.","output:","output_address,","output_address=0x00","output_flag","output_flag)","output_value)","output_value=0xff00","output_values)","output_values=[1,1,1,0,0,1,1,1,0,0,1,1,1]","outsid","over","overflow","overhead","overhead,","overridden","overview","overwritten","ow","own","owner.","p","p,","p.","p10","p10,","p11=scl)","p12","p12,","p13","p13,","p14","p14,","p15,","p16","p16,","p17,","p18","p18,","p18.","p19,","p2,","p20,","p20.","p21","p21,","p21.","p22","p22,","p23","p23.","p23:","p3,","p4,","p4:","p6","p6,","p6.","p8","p8,","p8/g15","p8:","p9","p9,","p_in","p_in()","p_in.callback(pin.irq_fal","p_out","p_out(true)","p_out.toggle()","p_out.value(0)","p_out.value(1)","pac","pac.","pack","packag","package)","package,","package.","package:","packaging),","packet","packet.","packets).","packets.","pacman","pad,","page","page,","page.","page:","pages:","pair","pair.","pairing.","pane","pane,","pane/bottom","panel","panel,","parallel","param","paramet","parameter.","parameters)","parameters,","parameters.","parameters:","parameters]","pariti","parity,","parity=none,","pars","parser","part","parti","particular","particular,","particularli","partit","partition,","partition]","partitions,","pass","passed\"","passed.","passes.","passiv","password","password)","password),","password,","password.","password:","password=\"your_api_key\",","past","path","path)","path):","path,","path.","paths.","pattern","pattern.","paus","payload","payload,","payloaddict","pc","pc.","pcb","pdf","peap","peculiar","peer","per","percent","percentag","perform","perform.","performed.","period","period).","period=150):","periodic:","periodic=false)","periodic=true)","periods.","peripher","peripheral,","peripheral_a.register0.","peripheral_a.register1.","peripheral_a.register[0]","peripherals,","perman","permanently.","permiss","permissions,","permit","persist","persistent,","person","personal,","personalis","personalisation)","personalisation.","personalization)","pertain","phase","phase=0)","phase=0,","phi","phi)","phi.","philosophi","phone/tablet),","phone/tablet/pc).","phones,","phr","phrase.","physic","pi,","pic","pic]","pic_rc1","pic`","pick","picocom","picocom,","pictur","pid),","piec","pig","pin","pin#6","pin(\"g7\",","pin('g16',","pin('g4',mode=pin.in,","pin('p10',","pin('p12',","pin('p9',","pin()","pin(0)","pin(1)","pin([value])","pin(pin.exp_board.g16,","pin(pin.module.p9,","pin),","pin):","pin,","pin.","pin.callback(trigger,","pin.exp_board","pin.exp_board.g16","pin.exp_board.g16.id()","pin.hold([hold])","pin.id()","pin.in","pin.in,","pin.init()","pin.init(mode,","pin.irq_fal","pin.irq_high_level","pin.irq_low_level","pin.irq_ris","pin.irq_rising,","pin.mode([mode])","pin.modul","pin.module.p9","pin.module.p9.id()","pin.open_drain","pin.out","pin.out,","pin.pull([pull])","pin.pull_down","pin.pull_up","pin.pull_up)","pin.pull_up,","pin.toggle()","pin.value()","pin.value([value])","pin:","pin='p12')","pin='p12',","pin='p16'","pin_handler(arg):","pin_handler)","pinout","pinouts,","pins.","pins/min","pins=('p10','p11'))","pins=('p12',","pins=('p19','p20','p21'))","pins=('p20',","pins=('p20','p21'))","pins=('p22',","pins=(clk,","pins=(sda,","pins=(txd,","pins=none,","pir","pir()","pitch","pkcs8","pkg","pkg:","pkg_len,","place","place.","placement","plain","plaintext","plan","platform","platform,","platform.","platforms).","platforms:","pleas","plug","plugging/unplug","plugin","plugin,","plugin.","plugin:","po","point","point,","point.","pointer","pointer,","points.","polar","polarity=0,","polici","poll","poll.modify(obj,","poll.poll([timeout])","poll.register(obj[,","poll.unregister(obj)","polling.","popul","popular","port","port)","port),","port,","port.","port/user).","port:","port=1883)","port]","port`","portabl","portable.","portal","portal,","portal.","portion","ports).","ports,","ports.","posit","position:","positional;","positions,","positive,","posix","possibl","possible.","post","post.","potenti","pow()","power","power!!!)","power!!!)................","power!!!)............................................................................","power),","power).","power,","power_mod","power_mode=lora.always_on,","power_sav","power_save=false,","practic","pre","preambl","preamble=8,","preced","precis","precision,","precision.","precompil","preconfigur","predefin","prefer","preference.","prefix","prefixes:","prepar","prerequisit","presenc","presence\")","present","present,","present.","present:","preserv","press","pressed.","pressur","pressure)","pressure,","pretti","prevent","previou","previous","previous_version:","previously.","primari","primarili","primit","princip","print","print(\"","print(\"%02d","print(\"\\nth","print(\"\\r%7d","print(\"a_lock","print(\"ack\")","print(\"approxim","print(\"client","print(\"connect","print(\"delet","print(\"deveui:","print(\"error","print(\"exit","print(\"fail","print(\"from","print(\"got","print(\"hello","print(\"http","print(\"messag","print(\"no","print(\"perform","print(\"pin","print(\"pow","print(\"pres","print(\"property:","print(\"receiv","print(\"request","print(\"scan","print(\"send","print(\"start","print(\"tim","print(\"too","print(\"upd","print(\"version:","print(\"wakeup","print(\"writ","print(\"{}","print('\\nrtc","print('adjust","print('attaching...')","print('aw","print('can","print('char","print('coil","print('connecting...')","print('device:","print('hold","print('input","print('lora","print('network","print('not","print('read","print('run","print('wlan","print('writ","print('{},{}'.format(pitch,","print()","print(1","print(adc_c.voltage())","print(address_book['alex'])","print(binascii.hexlify(sigfox.id()))","print(binascii.hexlify(sigfox.pac()))","print(bluetooth.get_adv())","print(bluetooth.resolve_adv_data(adv.data,","print(data)","print(e)","print(line)","print(lt.light())","print(message.payload)","print(message.topic)","print(msg)","print(networks[2])","print(original)","print(pycom_devices[0])","print(rtc.now())","print(s.recv(4096))","print(s.recv(64))","print(service.uuid())","print(services)","print(temp.read_temp_async())","print(ubinascii.hexlify(lora.mac()).upper().decode('utf","print(ubinascii.hexlify(mfg_data))","print(ubinascii.hexlify(sigfox.mac()))","print(value)","print(variable)","print(wake_s)","print(welcome_phrase)","print(wlan.ifconfig())","print(x)","printed.","printing:","prior","privaci","privat","prlen","problem","proce","procedur","procedure).","procedure.","procedure:","proceeding:","process","process,","process.","process:","processor","produc","product","product,","products,","products.","profil","program","program,","program.","programat","programming.","progress.","prohibited).","project","project).","project,","project.","project:","projects,","projects.","prompt","prompt).","prompt,","prompt.","proper","properli","properti","properties,","properties.","property()","protect","protected)","proto,","protocol","protocol,","protocol.","protocols.","protocols:","prototyping.","prove","provid","provided,","provided.","provider.","provis","provisioning.","pseudo","ptr","public","public,","public=false)","public=true)","public=true,","public_key","publish","publish,","pull","pull,","pull.","pull=none,","pull=pin.pull_up)","puls","pulse,","pulse.","pulse:","pulses,","pulses.","pulses_get","pulses_get(pin,","purpos","purpose.","purposes.","push","put","putti","putty.","pwd","pwd),","pwd]","pwm","pwm(0,","pwm.channel()","pwm.channel(0,","pwm.channel(id,","pwm_c","pwm_c.duty_cycle(0.3)","pwmchannel","pwmchannel.","pwmchannel.duty_cycle(value)","py","py,","py.go_to_sleep()","py.setup_int_pin_wake_up(false)","py.setup_int_wake_up(true,","py.setup_sleep(300)","pyabcde0","pyb.uart,","pyb.usb_vcp.","pyb:","pyboard","pybyt","pybytes).","pybytes,","pybytes.","pybytes.send_virtual_pin_valu","pybytes.send_virtual_pin_value(persistent,","pybytes:","pybytes;","pybytes?","pybytes_config.json","pycas","pycase,","pycod","pycom","pycom'","pycom.","pycom.heartbeat()","pycom.heartbeat([enable])","pycom.heartbeat(false)","pycom.heartbeat(true)","pycom.heartbeat_on_boot([enable])","pycom.io\\r\\nauthorization:","pycom.nvs_erase(key)","pycom.nvs_erase_all()","pycom.nvs_get('count')","pycom.nvs_get(key)","pycom.nvs_set('count',","pycom.nvs_set('temp',","pycom.nvs_set(key,","pycom.ota_finish()","pycom.ota_slot()","pycom.ota_start()","pycom.ota_write(buffer)","pycom.pulses_get()","pycom.pulses_get(pin,","pycom.rgbled(0x0000ff)","pycom.rgbled(0x001500)","pycom.rgbled(0x007f00)","pycom.rgbled(0x00ff00)","pycom.rgbled(0x150000)","pycom.rgbled(0x7f0000)","pycom.rgbled(0x7f7f00)","pycom.rgbled(0xff00)","pycom.rgbled(0xff0000)","pycom.rgbled(color)","pycom.rgbled(color=0xff0000)","pycom.rgbled(rgb_blue)","pycom.rgbled(rgb_green)","pycom.rgbled(rgb_red)","pycom.wdt_on_boot()","pycom.wdt_on_boot([enable])","pycom.wdt_on_boot(true)","pycom.wdt_on_boot_timeout()","pycom.wdt_on_boot_timeout(10000)","pycom.wdt_on_boot_timeout([timeout])","pycom.wifi_on_boot()","pycom.wifi_on_boot([enable])","pycom.wifi_on_boot(true)","pycom/pycom","pycom_devic","pycomawsmqttcli","pycomawsmqttclient.configureconnectdisconnecttimeout(config.conn_disconn_timeout)","pycomawsmqttclient.configurecredentials(config.aws_root_ca,","pycomawsmqttclient.configuredrainingfrequency(config.draining_freq)","pycomawsmqttclient.configureendpoint(config.aws_host,","pycomawsmqttclient.configurelastwill(config.last_will_topic,","pycomawsmqttclient.configuremqttoperationtimeout(config.mqtt_oper_timeout)","pycomawsmqttclient.configureofflinepublishqueueing(config.offline_queue_size)","pycomawsmqttclient.connect():","pycomawsmqttclient.subscribe(config.topic,","pycomawsmqttshadowcli","pycomawsmqttshadowclient.configureconnectdisconnecttimeout(config.conn_disconn_timeout)","pycomawsmqttshadowclient.configurecredentials(config.aws_root_ca,","pycomawsmqttshadowclient.configureendpoint(config.aws_host,","pycomawsmqttshadowclient.configuremqttoperationtimeout(config.mqtt_oper_timeout)","pycomawsmqttshadowclient.connect():","pycomawsmqttshadowclient.createshadowhandlerwithname(config.thing_name,","pycom'","pycoproc.pi","pycrypto.","pymakr","pymakr,","pymakr.","pymakr.conf","pymakr.conf.","pymakr;","pymakr@1.0.3)","pyscan","pyscan()","pyscan.","pyscan'","pysens","pysense()","pysense),","pysense).","pysense,","pysense.","pysense.pi","pysense/pytrack","pysense/pytrack/expans","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","pysense/pytrack/pyscan/expans","pysense:","pysense_x.x.x.dfu","pysense'","pyseri","python","python,","python.","python3","python3.","pytrack","pytrack'","pytrack()","pytrack,","pytrack.get_sleep_remaining()","pytrack.get_wake_reason()","pytrack.go_to_sleep([gps=true])","pytrack.setup_int_pin_wake_up([rising_edg","pytrack.setup_int_wake_up(rising,","pytrack.setup_sleep(time_seconds)","pytrack.setup_sleep(timout_sec).","pytrack/pysens","pytrack/pysense,","pytrack/pysense/pyscan.","pytrack/pysense/pyscan/expans","pytrack:","pytrack_0.0.8.dfu","pytrack_0.0.8.dfu):","pytrack'","q","q,","q.","q]","quantiti","queri","queu","queue","queue,","queue.","quick","quickli","quiescent","quiet","quiet`","quit","quot","r","r,","r]","r_b","ra5).","race\"","racer","rad","radian","radians.","radio","radio.","rais","raised.","ram","ram.","random","randomli","rang","range()","range(0,","range(0xff):","range(1,","range(10):","range(2):","range(3):","range(8):","range(len(data)):","range,","range.","rate","rate'","rate':","rate.","rate:","ratio","raw","rbuf","rbuf)","rc1,","rcz","rcz1","rcz2","rcz3","rcz4","rcz4.","rcz=sigfox.rcz1)","rcz=sigfox.rcz1,","re","reach","read","read()","read(self):","read,","read.","read/writ","read_bit(self):","read_buf)","read_buf.","read_byte(self):","readabl","reader","reader:","readers.","readi","reading.","readonly=false)","ready,","ready.","real","realli","reason","reason,","reason.","reason:","reboot","reboot.","reboots,","reboots.","receiv","receive,","received')","received,","received.","received...","receiver.","receiving,","recent","reception.","recipient'","recognis","recommend","recommended.","reconfigur","reconnect","reconnect.","record.txt',","recov","recover","recovered.","recoveri","recurs","recv_ack","recv_ack)","recv_data","recv_data)","recv_pkg","recv_pkg)","recv_pkg[1]","recv_pkg_len","recv_pkg_len,","recycl","red","red,","reduc","refer","referenc","reference,","reference.","referenced.","reflash","refus","regard","regardless","regex","regex.match(string)","regex.search(string)","regex.split(string,","region","region)","region=lora.eu868)","region=lora.us915)","region]","regions:","regist","register.","register/manag","register_address,","register_address=0x01","register_quantity,","register_quantity=100","register_valu","register_value))","register_value,","register_value=","register_values,","register_values=[2,","registered,","registers)","registers,","registers.","registr","registration\";","registration,","registration.","registri","regul","regular","regularli","reinstal","rejected!\")","rel","relat","releas","release='1.17.0.b1',","released.","relev","reli","reliabl","reload","remain","remaind","remaining:","remap","rememb","remot","remotely.","remov","remove()","removed,","renam","repeat","repeat.","repeatedli","repetit","repl","repl)","repl,","repl.","repl:","replac","replay","repli","repo.","report","reposit","repositori","repository.","repr()","repres","represent","representation.","represents:","republish","reqa.","request","request\")","request.","request/repli","requests.","requir","require.","required),","required.","resend","reset","reset\")","reset(self):","reset).","reset,","reset.","reset;","reset`","resets,","resets.","resid","resistor","resistor.","resistor:","resiz","resolut","resolution,","resolution:","resolv","resolve_adv_data()","resourc","respect","respectively.","respond","respond.","respons","response.","response:","responsestatu","responsestatus,","rest","restart","restor","restrict","restriction,","result","result.","result:","results.","resum","retain","retri","retriev","return","return_cod","return_flag","returned).","returned.","returning.","returns,","returns:","reus","reused.","reversed()","revert","review","rf","rfid","rfid/nfc","rgb","rgb_bright","rgb_red","rgbled.","right","rightmost","rippl","rise","risk","rmt","rmt(channel=4,","rmt.","rmt.deinit()","rmt.high","rmt.high))","rmt.init()","rmt.init(gpio,","rmt.init(gpio=\"p20\",","rmt.init(gpio=\"p21\",","rmt.low,","rmt.low.","rmt.pulses_get()","rmt.pulses_get(pulses,","rmt.pulses_get(pulses=100)","rmt.pulses_get(timeout=500)","rmt.pulses_send(duration,","rmt.recv_pulses()","rmt.send_pulses(duration,","rn2483","robot","role","roll","roll))","roll,","rom","rom):","rom,","rom0","rom:","root","round","round()","rout","router","router.eu.thethings.network).","row","rsa","rsaprivatekey\"","rssi","rssi).","rssi,","rssi_threshold","rst","rt","rtc","rtc()","rtc(id=0)","rtc,","rtc.","rtc.init((2014,","rtc.init((2017,","rtc.init()","rtc.init(datetime)","rtc.init(datetime=(2014,","rtc.init(datetime=none,","rtc.internal_rc","rtc.internal_rc,","rtc.now()","rtc.now())","rtc.now()))","rtc.now(),","rtc.ntp_sync(\"pool.ntp.org\")","rtc.ntp_sync(server,","rtc.synced()","rtc.xtal_32khz","rtm","rtos),","rtr","rtr,","rtr=false,","rtr=true)","rts,","rts/ct","rtu","rtu).","rule","rule.","run","run).","run,","run/sync","run:","running,","running:","runs.","runtim","runtimeerror","rx","rx/tx","rx:',","rx_filter_threshold","rx_filter_threshold,","rx_filter_threshold=20)","rx_idle_threshold","rx_idle_threshold,","rx_idle_threshold.","rx_idle_threshold=1000)","rx_idle_threshold=1000,","rx_idle_threshold=12000)","rx_iq","rx_iq=false,","rx_iq=true,","rx_queue_len","rx_queue_len=128,","rx_timestamp","rxd","rxd,","s","s,","s.bind(1)","s.close()","s.connect((self.ip,self.port))","s.connect(socket.getaddrinfo('www.google.com',","s.connect(socket.getaddrinfo('www.micropython.org',","s.recv(128)","s.recv(32)","s.recv(64)","s.recvfrom(128)","s.send('')","s.send('devic","s.send('hello","s.send('hello')","s.send('ping')","s.send('pong')","s.send(b\"get","s.send(bytes([0x01,","s.send(bytes([0x04,","s.send(bytes([1,","s.setblocking(false)","s.setblocking(true)","s.setsockopt(socket.sol_lora,","s.setsockopt(socket.sol_sigfox,","s.settimeout(5.0)","s.settimeout(5.5)","s1","safe","safe_boot_on_upload","same","sampl","sample.","save","save.","saved.","scalabl","scalar","scale","scale.","scan","scan(self):","scanned.","scanning.","schemat","scheme","schmidt","schmidt,","sck","sck,","scl","scl)","scl))","scl='p21',","sclk","screen","screen,","screen.","screen:","screw","script","script,","script.","script/program","scripts,","scripts.","scripts:","scroll","sd","sd()","sd.deinit()","sd.init()","sd.init(id=0)","sda","sda,","sda='p22',","search","search()","search/navig","seat","sec","sec\")","sec,","second","second,","second[,","secondli","secondly,","seconds)","seconds,","seconds.","secret","section","section,","section.","sections.","secur","secure=on","secure_boot","secure_boot_signing_key.pem","secure_key=secure_boot_signing_key.pem","secureboot","secureboot,","security.","security:","see","seem","seen","segment","segment_s","segment_size)","select","select.poll()","select.poll*","select.pollerr","select.pollhup","select.pollin","select.pollout","select.pollout.","select.select(rlist,","select_rom(self,","selected,","selected.","self.__alarm","self._search_rom(rom,","self.addr","self.bas","self.i2c","self.i2c.readfrom(self.addr,","self.i2c.writeto(addr,","self.ip","self.period","self.pin","self.pin.init(pin.open_drain,","self.port","self.read_bit()","self.read_bit():","self.reset()","self.reset():","self.second","self.seconds)","self.sendrequest(\"type=command¶m=switchlight&idx=\"+idx+\"&switchcmd=\"+command)","self.sendrequest(\"type=command¶m=updateuservariable&vtype=0&vname=\"+name+\"&vvalue=\"+value)","self.tim","self.valu","self.write_byte(b)","self.write_byte(cmd_matchrom)","self.write_byte(cmd_searchrom)","self.write_bytes(rom)","sell","semant","semaphores)","semtech","send","send.","send_at_cmd_pretty('at!=\"fsm\"')","send_at_cmd_pretty('at!=\"showphy\"')","send_at_cmd_pretty(cmd):","sending/receiv","sending/receiving.","sendrequest(self,","senet","sens","sensibl","sensing.","sensor","sensor)","sensor,","sensor.","sensor:","sensors.","sensors_data","sent","sent')","sent,","sent/receiv","sep","sep])","separ","sequan","sequenc","sequenti","sequentially,","ser=py343434","seri","serial","serial,","serial.","serial:","serialport","serv","server","server(login=('user',","server)","server).","server,","server.","server.deinit()","server.init(*","server.init(login=('user',","server.isrunning()","server.timeout()","server.timeout(300)","server.timeout([timeout_in_seconds])","server_ip","server_ip,","server_side=false,","servers.","server'","servic","service.","service.characteristic('temp',","service.characteristic(uuid,","service.characteristics()","service.instance()","service.isprimary()","service.start()","service.stop()","service.uuid()","service.uuid())","service_data","service_data=none,","service_uuid","service_uuid=b'1234567890123456')","service_uuid=none)","services,","services.","services:","services​","session","session,","session.","set","set,","set.","set:","set_advertisement()","set_pullups).","setattr()","setlight(self,","setsockopt()","settimeout()","settings!!","settings,","settings.","settings:","setup","setup,","setup_sleep()","setvariable(self,","sever","sf","sf7","sf=12)","sf=7,","sfrx","sfrx,","sftx","sftx,","sha","sha1","shadow","shall","shape","share","sheets,","shell.","shield","shield\"","shield,","shield.","shields,","shields.","shift","shifting,","shipped,","shock","short","short.","shortcut","shorter","shortest","shorthand","shortly.","shouldn't","show","showing.","shown","shutdown","si7006a20","si7006a20(pysens","si7006a20.","si7006a20.humidity()","si7006a20.temperature()","side","side,","side.","sidebar)","sidebar,","sides.","sigfox","sigfox(mode=sigfox.fsk,","sigfox(mode=sigfox.sigfox,","sigfox).","sigfox,","sigfox.","sigfox.frequencies()","sigfox.fsk","sigfox.fsk.","sigfox.id()","sigfox.init(mode=sigfox.sigfox,","sigfox.mac()","sigfox.pac()","sigfox.public_key()","sigfox.public_key([public])","sigfox.public_key(true)","sigfox.rcz1,","sigfox.rcz2,","sigfox.rcz3,","sigfox.rcz4","sigfox.rcz4.","sigfox.rssi()","sigfox.sigfox","sigfox.sigfox,","sigfox.sigfox.","sign","signal","signal'","signal,","signal.","signals,","signals.","signatur","signature_verification_key.bin","signed)","signed=tru","signific","silent","silently.","sim","sim.","similar","similar.","simpl","simplest","simpli","simplifi","simul","simultan","sine","singapore,","singl","sinwav","sipi","sipy,","sipy.","sipy:","sit","site","site.","situations.","size","size)","size,","size.","size/byt","size=0","sizes.","sketch","skill","slave","slave,","slave.","slave_addr=0x0a","sleep","sleep(5)","sleep)","sleep.","sleep_m","sleep_ms()","sleep_ms(20)","sleep_u","sleep_us()","sleep_us(1)","sleep_us(40)","sleep_us(420)","sleep_us(480)","sleep_us(60)","slightli","slot","slot.","slowly.","sm","sma","smac","small","smaller","smallest","smart","sms.","sn65hvd230.","snif","snippet","snippet:","snr","snr,","so,","so:","sock","sock.setblocking(false)","sock.setblocking(true)","sock.settimeout(0.0)","sock.settimeout(none)","sockaddr)","socket","socket).","socket,","socket.","socket.accept()","socket.af_inet,","socket.af_lora","socket.bind(address)","socket.bind(port_number)","socket.close()","socket.connect(address)","socket.error,","socket.getaddrinfo().","socket.getaddrinfo(host,","socket.ipproto_tcp","socket.ipproto_tcp)","socket.ipproto_udp,","socket.listen([backlog])","socket.makefile(mode='rb')","socket.read(size)","socket.readall()","socket.readall(),","socket.readinto(buf[,","socket.readline()","socket.recv(bufsize)","socket.recvfrom(bufsize)","socket.send(bytes)","socket.send(bytes).","socket.sendall(bytes)","socket.sendto(bytes,","socket.setblocking(flag)","socket.setsockopt(level,","socket.settimeout(value)","socket.so_bit","socket.so_bit,","socket.so_confirmed,","socket.so_dr","socket.so_dr,","socket.so_oob,","socket.so_reuseaddr","socket.so_rx,","socket.so_tx_repeat,","socket.sock_dgram,","socket.sock_raw","socket.sock_raw)","socket.sock_stream,","socket.socket()","socket.socket(socket.af_inet,","socket.socket(socket.af_lora,","socket.socket(socket.af_sigfox,","socket.socket,","socket.sol_lora,","socket.sol_sigfox","socket.sol_socket,","socket.timeout","socket.write(buf)","socket:","sockets,","sockets.","soft","softwar","software,","software.","solder","solution!","solution:","some_asset.txt","some_library.pi","someth","sometim","somewher","soon","soon.","sort","sorted()","sourc","source,","source.","source:","source=rtc.internal_rc)","sources.","sources:","south","space","space.","span","spans.","spawn","spec","special","specif","specifi","specific,","specific.","specification:","specified,","specified.","spectrum,","speed","speed,","speed.","speed]","speed`","sphinx","spi","spi(0,","spi,","spi.deinit()","spi.init(mode,","spi.lsb","spi.lsb.","spi.mast","spi.master.","spi.msb","spi.read(5)","spi.read(nbytes,","spi.readinto(buf,","spi.write(buf)","spi.write(bytes([0x01,","spi.write_readinto(bytes([0x01,","spi.write_readinto(write_buf,","split","spread","sqnsupgrad","sqnsupgrade.run('/sd/catm1","sqnsupgrade.run('/sd/nb1","sqnsupgrade.run('serial_port',","sqnsupgrade.uart()","sqnsupgrade.uart(true)","sqnsupgrade.uart(true,'/flash/updater.elf')","squar","srv1","srv1.characteristic(uuid=b'ab34567890123456',","ss","ss.connect(socket.getaddrinfo('cloud.blynk.cc',","ss.connect(socket.getaddrinfo('www.google.com',","ssid","ssid',","ssid,","ssid.","ssid:","ssid:gpi","ssid='wipi","ssid=none,","ssid=original_ssid,","ssid]","ssl","ssl.cert_none,","ssl.cert_optional,","ssl.cert_required:","ssl.sslerror","ssl.sslsocket,","ssl.wrap_socket().","ssl.wrap_socket(s)","ssl.wrap_socket(s,","ssl.wrap_socket(sock,","ssl:","ssleay","st","st_atime:","st_ctime:","st_dev:","st_gid:","st_ino:","st_mode:","st_mtime:","st_nlink:","st_size:","st_uid:","sta","stabl","stack","stack.","stand","standard","standard)","standard.","standardis","standards.","start","start,","start.","start=true)","start_level","start_level)","start_level=rmt.high)","started!","started,","started.","started:","starting,","starting_address,","starting_address=0x0","starting_address=0x00","state","state(2)","state.","statement","statement,","static","static.ex","staticmethod()","station","station:","statu","status(0)","status,","status.split(\"","status:","stay","stefan","step","step,","step:","steps:","still","stop","stop=1)","stop=1,","stop=true)","stopwatch.","storag","storage.","store","store,","store/manag","store:","stp","str","str(i))","str(loopcount)","str(payloaddict[\"state\"][\"desired\"][\"property\"]))","str(payloaddict[\"state\"][\"property\"]))","str(payloaddict[\"version\"]))","str(py.get_sleep_remaining())","str(py.get_wake_reason()))","str(s.readline(),","straight","straightforward","stream","stream.","stream/connect","streamlin","strength","strictli","string","string)","string,","string.","strings,","strings.","strong,","strongli","struct","struct.pack(_lora_pkg_ack_format,","struct.pack(_lora_pkg_format","struct.pack(lora_pkg_format,","struct.unpack(\">l\",","struct.unpack(_lora_pkg_ack_format,","struct.unpack(_lora_pkg_format","struct.unpack(lora_confirm_format,","structur","structure\"","structure.","structure:","structures)","structures).","structures.","structures:","stuck","studio","style","sub","sub_cb(topic,","subclasses:","subject","sublicense,","subnet,","subnet_mask,","subscib","subscrib","subscript","subsequ","subset","substanti","substitut","substr","subsystem","subsystem.","subtract","subtyp","succe","succeed.","succeeded!')","succeeded')","succeeded.","succeeds.","success","success.","successful,","successfulli","successfully,","such","sudo","sudo)","sudo.","suffici","suggest","suggests).","suit","suitabl","suitable.","sum","sum()","summari","sun","super","super()","suppli","supplied)","supplied,","support","support).","supported.","suppress","sure","surround","swapping.","switch","sy","symbol","symbols.","symmetr","sync","sync.","sync_file_typ","sync_fold","synced,","synchronis","synchronisation,","syntax","syntax,","syntax.","sys.argv:","sys.byteorder:","sys.exit()","sys.exit(retval=0)","sys.implement","sys.implementation:","sys.maxs","sys.maxsize:","sys.modules:","sys.path:","sys.platform:","sys.print_exception(exc,","sys.stderr:","sys.stdin:","sys.stdout","sys.stdout:","sys.version:","sys.version_info:","system","system\"","system,","system.","system/micropython","system;","systemexit","systemexit.","system'","t","tab","tab,","tab.","tab;","tabl","table.","tail","taiwan,","take","taken","taken,","tale","talk","tangent","tar","tar,","tar[.gz]","tar]","target","target:","target=[boot|app]","target=app","target=boot","task","tasks)","tasks,","tcp","tcp)","technic","technolog","technology.","telemetri","tell","telnet","telnet,","telnet.","telstra","temp","temp.start_conversion()","temp_lsb","temp_read","temperatur","temperature,","temperature.","termin","terminal,","terminal/atom","terminal:","terminology)","terms.","test","test.","test:","text","text.","th_func(delay,","that,","that.","that'","thekeyfil","them,","them.","there!","there'","therefor","therefore,","there'","the“instal","thing","thing.","things'","things.","things:","third","this,","this.","this:","this_script.pi","those","though","thousand","thread","thread,","thread.","threads,","threads.","three","threshold","through","throughput","throughput.","thu","tick","ticket","ticks_*()","ticks_cpu().","ticks_diff()","ticks_m","ticks_ms()","ticks_ms(),","ticks_us()","ticks_us(),","ticks_us,","tilt","time","time,","time.","time.sleep(.5)","time.sleep(0.050)","time.sleep(0.1)","time.sleep(0.25)","time.sleep(0.5)","time.sleep(1)","time.sleep(1.25)","time.sleep(1.5)","time.sleep(2)","time.sleep(2.5)","time.sleep(4)","time.sleep(5)","time.sleep(delay)","time.sleep(machine.rng()","time.sleep_ms(100)","time.sleep_ms(50)","time.sleep_ms(500)","time.sleep_u","time.ticks_diff(start,","time.ticks_us()","time.ticks_us())","time.time()","time.timezon","timeout","timeout)","timeout,","timeout.","timeout:","timeout=","timeout=0)","timeout=10000)","timeout=30)","timeout=300)","timeout=5000)","timeout=60)","timeout=600)","timeout=none,","timeout])","timeout_char","timeout_chars=2,","timeout_m","timeouterror","timer","timer.","timer.alarm(handler=none,","timer.alarm(self._seconds_handler,","timer.chrono()","timer.sleep_us()","times.","timestamp","timezon","timezone',","timezone,","timezone.","tinker","tip","tls:","to,","to.","to/from","to:","togeth","together,","together.","toggl","toggled.","token","token):","token.","token:","token]","tolerant,","tone","too).","too,","too.","took","tool","tool,","tool.","tools,","tools/featur","top","topbar.","topic","topic,","topic:","topics.","tormod","tort","total","total)","touch","toward","trace","traceback","traceback.print_exception(),","track","tracking,","traffic","transact","transaction).","transaction:","transceiv","transfer","transfer,","transfer.","transform","transit","translat","transmiss","transmission.","transmissions,","transmissions.","transmit","transmitted.","transport","transport.","trash","travel","treat","tree.","tri","trials,","triangl","trick","trigger","trigger,","trigger=can.rx_fram","trigger=can.rx_frame)","trigger=pin.irq_fal","triggered.","trivial","troubleshoot","true","true)","true,","true.","true/false.","true:","true])","truncat","try:","ttls),","ttls:","ttn","ttn.","ttyusb.","tupl","tuple).","tuple,","tuple.","tuple:","tuples,","turn","tutori","tutorial.","tutorials,","tutorials.","two","two'","two.","tx","tx,","tx/rx,","tx:","tx_carrier","tx_carrier)","tx_counter","tx_counter,","tx_frequenc","tx_frequency)","tx_idle_level","tx_idle_level,","tx_idle_level=0)","tx_idle_level=rmt.low)","tx_idle_level=rmt.low,","tx_iq","tx_iq=false,","tx_iq=true,","tx_onli","tx_power","tx_power,","tx_power.","tx_power=14,","tx_retri","tx_retries=1,","tx_time_on_air","tx_time_on_air,","tx_trial","tx_trials,","txd","txd,","txd.","txt,","ty","type","type()","type(service.uuid())","type,","type.","type:","typed.","typeerror:","types,","types.","types:","typic","tzinfo","tzinfo]]]]])","u","u.fl","uart","uart(1,","uart.","uart.any()","uart.deinit()","uart.even","uart.even,","uart.init(9600,","uart.init(baudrate=9600,","uart.odd","uart.odd.","uart.read(10)","uart.read(5)","uart.read([nbytes])","uart.readall()","uart.readinto(buf)","uart.readinto(buf[,","uart.readline()","uart.rx_ani","uart.sendbreak()","uart.wait_tx_done(timeout_ms)","uart.write('abc')","uart.write('hello')","uart.write(buf)","uart/usart","uart1","uart2","uart_1","ubinascii","ubinascii.a2b_base64(data)","ubinascii.b2a_base64(data)","ubinascii.hexlify()","ubinascii.hexlify(adv.mac)","ubinascii.hexlify(b'12345')","ubinascii.hexlify(data[,","ubinascii.hexlify(hash.digest())","ubinascii.unhexlify('00000005'))[0]","ubinascii.unhexlify('00112233445566778899aabbccddeeff')","ubinascii.unhexlify('00250c0000010001')","ubinascii.unhexlify('11b0282a189b75b0b4d2d8c7fa38548b')","ubinascii.unhexlify('2b7e151628aed2a6abf7158809cf4f3c')","ubinascii.unhexlify('70b3d57ed0008cd6')","ubinascii.unhexlify('ada4dae3ac12676b')","ubinascii.unhexlify('b57f36d88691cec5ee8659320169a61c')","ubinascii.unhexlify(data)","ubuntu","ucrypto","ucrypto.aes(key,","ucrypto.decrypt()","ucrypto.encrypt()","uctyp","uctypes.addressof(),","uctypes.addressof(obj)","uctypes.bfuint16","uctypes.big_endian","uctypes.bytearray_at(addr,","uctypes.bytes_at(addr,","uctypes.little_endian","uctypes.n","uctypes.sizeof(struct)","uctypes.struct()","uctypes.struct(addr,","uctypes.uint32","uctypes.uint8","uctypes.uint8),","udp","ue","uhashlib","uhashlib.md5([data])","uhashlib.sha1([data])","uhashlib.sha224([data])","uhashlib.sha256([data])","uhashlib.sha384([data])","uhashlib.sha512([data])","uid","uid.","uid:","uid]","uid_len))","uint16","uint16,","uint16.","ujson","ujson.dumps(obj)","ujson.load(fp)","ujson.loads(str)","ulp","ultra","umodbu","unabl","unaccept","unaffected.","unavail","unavailable.","unb","unbound","uncondition","unconditionally,","undefin","undefined.","under","underli","underlyingly,","underscor","understand","understanding.","unexpect","unfeas","unfortun","unfortunately,","unhandl","uninstal","uniqu","unique,","unit","unit).","unit.","univers","unix","unless","unlik","unlock","unlocked.","unmount","unpack","unplug","unregist","unsuccessful,","until","unusu","uo","uos.chdir(path)","uos.dupterm(stream_object)","uos.getcwd()","uos.getfree(path)","uos.listdir([dir])","uos.mkdir(path)","uos.mkfs(block_devic","uos.mount(block_device,","uos.remove(path)","uos.rename(old_path,","uos.rmdir(path)","uos.sep:","uos.stat(path)","uos.sync()","uos.uname()","uos.unlink(path)","uos.unmount(path)","uos.urandom(n)","up","up\")","up)","up,","up.","updat","update,","update.","update:","update\\","update_period","update_period=3600)","updated,","updated.","updater.","updater.elf","updater;","updates.","upgrad","upgrade,","upgrade.","upgrades).","upgrading,","uplink","upload","upload,","upload.","uploaded.","uploading.","upon","upper","uptime,","upward","ur","urandom","ure.compile().","ure.compile(regex)","ure.debug","ure.match(regex,","ure.search(regex,","url","url'","url,","url:","us","us)","us,","us.","us915","us915.","us:","usa,","usability,","usabl","usag","usage,","usage:","usb","usb\"","usb)","usb.","use,","use.","use:","used,","used.","used/import","used;","useful,","user","user,","user.","userdata,","userid","usermod","usernam","username,","username:","users,","users.","using.","using:","usocket","ussl","ustruct","ustruct.calcsize(fmt)","ustruct.pack(fmt,","ustruct.pack_into(fmt,","ustruct.unpack(fmt,","ustruct.unpack_from(fmt,","usual","usual...","utc","utc.","utc:',","util","util.","util/tickets/","util:","utilis","utility:","utim","utime.gmtime([secs])","utime.localtime(),","utime.localtime([secs])","utime.mktime()","utime.sleep(seconds)","utime.sleep_ms(750)","utime.sleep_ms(ms)","utime.sleep_us(us)","utime.ticks_cpu()","utime.ticks_diff(old,","utime.ticks_ms()","utime.ticks_us()","utime.time()","utime.timezone(7200)","utime.timezone([secs])","uucp/dialout","uuid","uuid.","uuids,","v","v,","v0.9","v1,","v1.0","v1.18.1.r1","v1.4.6","v2,","v2.0","v3","v3,","v3.0","v:","v]","val","valid","valid_card","valu","value)","value))","value).","value):","value,","value.","value:","value=1)","value=25)","value=5)","valueerror","values,","values.","values:","vari","variabl","variable).","variable,","variable.","variables,","variables.","variant.","variat","varieti","variou","vdd/2.","vector","vector):","vector.","vehicl","vehicle.","vendor","verbos","verbose.","verbose`","veri","verif","verifi","verizon","verizon,","verizon:","versa.","version","version,","version.","version:","version;","version='v1.8.6","versions.","via","vice","vid:pid=04d8:f013","view","vin","vin,","vin:","virtual","visibl","visible.","visit","visual","visualis","visualisation:","vodafone:","volatil","volden","voltag","voltage)","voltage.","voltmet","vpp)","vpp),","vpp).","vref","vs","vscode","vscode.","w","w.deinit()","w01","w01,","w01:","wait","wait.","waitflag","waiting,","waiting_ack","wake","wake,","wake_","wake_reason_acceleromet","wake_reason_int_pin","wake_reason_push_button","wake_reason_tim","wake_s['wake']","wakeup","wakeup.","wakeup...","walk","want","warn","warning,","warning:","warranti","watchdog","water","wave","wavelength","way","way,","way.","way:","ways:","ways;","wb).","wdt","wdt(timeout=2000)","wdt.feed()","wdt.init(timeout)","wdt_on_boot_timeout.","we'r","we'v","web","websit","website):","website.","week,","weekday","weekday,","weekli","weight","welcom","welcome(\"alex\")","welcome(name):","welcome_phras","well","well,","well.","welt","weston","whatev","whenev","where:","whether","while(true):","while(waiting_ack):","whilst","white","whole","whose","wi","wide","wide.","widget","widget'","widget.","widgets.","width","wifi","wifi,","wifi.","wifi/bluetooth","wifi/bt","wifi/uart","wifi/wlan.","wifi\\n\")","wifi_pass","wifi_pw,","wifi_ssid","wifi_ssid,","wifiota","wifiota(wifi_ssid,","window","window.","windows,","windows.","windows/linux","windows:","windows;","wipi","wipy,","wipy.","wipy2","wipy2,","wipy2:","wipy3","wipy3,","wipy3:","wipy:","wire","wireless","wirelessly.","wires:","wish","with.","within","without","wizard","wizard,","wl","wl.auth()","wl.connect(net_to_use,","wl.ifconfig()[0])","wl.ifconfig(config=net_properties['wlan_config'])","wl.init(mode=wlan.ap,","wl.isconnected():","wl.mode(wlan.sta)","wl.scan()","wl.ssid()","wlan","wlan',","wlan()","wlan(mode=wlan.sta)","wlan(wlan.sta)","wlan,","wlan.antenna([antenna])","wlan.ap","wlan.ap,","wlan.ap.","wlan.auth([auth])","wlan.channel([channel])","wlan.connect(\"yourwifinetwork\",","wlan.connect('mywifi',","wlan.connect('your","wlan.connect(net.ssid,","wlan.connect(ssid,","wlan.connect(ssid='mynetwork',","wlan.connect(ssid='mywifi',","wlan.deinit()","wlan.disconnect()","wlan.ext_","wlan.ext_ant.","wlan.ifconfig(config=('192.168.0.107',","wlan.ifconfig(config=('192.168.0.4',","wlan.ifconfig(config=('192.168.178.107',","wlan.ifconfig(id=0,","wlan.init(mode,","wlan.init(mode=wlan.ap,","wlan.init(mode=wlan.sta)","wlan.int_ant,","wlan.isconnected()","wlan.isconnected():","wlan.mac()","wlan.mode()","wlan.mode([mode])","wlan.scan()","wlan.ssid([ssid])","wlan.sta,","wlan.sta_ap","wlan.sta_ap.","wlan.wep","wlan.wep,","wlan.wpa,","wlan.wpa2","wlan.wpa2,","wlan.wpa2.","wlan.wpa2_","wlan.wpa2_ent.","wlan_config","wlist,","wmac","wob","woken","won't","won't","word","word.","words,","work","work.","workaround","working,","working.","world\"","world.","wpa2","wrap","wrapper","write","write()","write.","write=0x00)","write_buf","write_bytes(self,","write_flash","writing,","written","written,","written.","wrong","wrong,","wrong.","ws2812b","wupa","www.pycom.io","www.pycom.io.","x","x)","x,","x.","x.x.x","x/y.","x/y/z","x]","xlist[,","xml","xxx","xxxx","xxxx,","y","y)","y.","y/x.","yaw","yaw.","year","yearday","yearday)","yellow","yet,","you'll","you'r","you'v","you.","you?","yourself","you'll","you'r","you'v","yum","z","z,","z.","zadig","zealand,","zealand.","zero","zero)","zero,","zero.","zip","zip()","zone","zones:","zsp0","zsp1","{","{\"b\":","{'alex':'2604","{'pwd':","{list,chip_id,wmac,smac,sigfox,exit,flash,copy,write,write_remote,wifi,pybytes,cb,nvs,ota,lpwan,erase_fs,erase_all}","{}","{}\".format(chr.value()))","{}\".format(coord,","{}\".format(ubinascii.hexlify(adv.mac)))","{}'.format(char.uuid(),","{}'.format(service.uuid()))","{}\\n\".format(coord,","|","|=","}","})","},","~/.atom/.apm/pymkr","~/.atom/.apmrc","~/.atom/packages/pymakr","~/.config/atom/cach","~/.screenrc","​","​aw","​integr","–","—","—version","‘fail","‘firmwar","‘hello')","‘past","‘serialport'","“a","“availability:”","“gener","“python=/usr/bin/python2.7”","“p”","“software”),","“x\"","→","✔"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Introduction\nWelcome to the Pycom documentation site. We recommend reading through all the sections to familiarise yourself with the various tools and features available to you to help you develop on your Pycom module.\nTo get started, read through the Getting Started Guide then feel free to jump straight into the tutorials and examples in Tutorials & Examples to begin building your projects.\n\nProducts\nGetting Started\nPymakr\nTutorials\nAPI Documentation\nProduct Info\nPybytes\n\n"},"products.html":{"url":"products.html","title":"Pycom Products","keywords":"","body":"Pycom Products\nPycom Products\nBelow you will find tables of all Pycom products. These tables illustrate the functionality of our various products, their compatibility with each other, as well as what accessories are required to utilise certain functionality.\nDevelopment Boards\n\n\n\nModule\nWiFi\nBluetooth\nLoRa\nSigfox\nLTE CAT-M1NB-IoT\n\n\n\n\nWiPy 3.0\n✔\n✔\n\n\n\n\n\nSiPy\n✔\n✔\n\n✔\n\n\n\nGPy\n✔\n✔\n\n\n✔\n\n\nLoPy\n✔\n✔\n✔\n\n\n\n\nLoPy4\n✔\n✔\n✔\n✔\n\n\n\nFiPy\n✔\n✔\n✔\n✔\n✔\n\n\nAntennas\nExternal WiFi/BT Antenna Kit\nExternal WiFi/BT Antenna Kit\nLoRa & Sigfox Antenna Kit\nLoRa & Sigfox Antenna Kit\nLTE-M Antenna Kit\n\n\n\nAccessories\n\n \n \n Accessory\n Expansion Board\n \n Pysense\n \n Pytrack\n \n Pyscan\n \n \n \n \n \n PyCase\n \n ✔\n \n \n \n \n \n IP67 Case for Expansion Board\n \n ✔\n \n \n \n \n \n IP67 Case for Pysense/Pytrack/Pyscan\n \n \n ✔\n ✔\n ✔\n \n \n IP67 Case (universal)\n \n ✔\n ✔\n ✔\n ✔\n \n \n LiPo Battery (user-supplied)\n ✔\n ✔\n ✔\n ✔\n \n \n Micro USB Cable Required (user-supplied)\n ✔\n ✔\n ✔\n ✔\n \n \n## OEM Modules\n\n\n\nOEM Module\nL01/W01 Reference Board\nUniversal Reference Board\n\n\n\n\nW01\n✔\n✔\n\n\nL01\n✔\n✔\n\n\nL04\n\n✔\n\n\nG01\n\n✔\n\n\n\n"},"gettingstarted/introduction.html":{"url":"gettingstarted/introduction.html","title":"Introduction","keywords":"","body":"Introduction\nSo, you've decided to order a Pycom development module. Firstly we would like to congratulate you in making an excellent decision. If you haven't yet placed your order we highly recommend you check out the products page before you place your order to ensure you know which accessories you might require.\n\nStep 1: Setting up the hardware\nIn the first part of this getting started guide, we will take you through setting up your device. Firstly we will cover how to connect the module to your computer either via USB or WiFi. Secondly we will explain how to connect various accessories such as antennas or SIM cards to your module.\nStep 2: Setting up your computer\nNow that your module is successfully connected, you will need to install some software on your computer to interface with it. The second part of this guide will guide you through installing drivers; performing firmware updates for your module/accessories to ensure you have the most stable and feature packed version; and how to setup the software use to program the device.\nStep 3: Using your module\nNow that you have a connected module and all the required software installed it is time to begin programming your device. This part of the guide will get you started with a basic example and point you in the right direction for getting your device connected to your chosen network.\nStep 4: Connecting to a network\nNow that you familiar with programming your device you will no doubt be keen to get it connected to one of the advertised wireless networks. This usually requires some registration. This step will detail how to get registered and connected to various wireless networks.\nYou can navigate through this guide using the arrow buttons at the bottom of the page.\n\n"},"gettingstarted/connection/":{"url":"gettingstarted/connection/","title":"Hardware Setup","keywords":"","body":"Hardware Setup\nThis chapter of the documentation will show you how to connect you Pycom module. For each device there are detailed instructions on how to connect your module to one of our base boards, a USB UART adapter or WiFi as well as what antennas you might need to connect. Please select your module below to be taken to the appropriate guide.\n"},"gettingstarted/connection/lopy.html":{"url":"gettingstarted/connection/lopy.html","title":"LoPy","keywords":"","body":"LoPy\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWiFiLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the LoPy module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the LoPy module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the LoPy module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\nFirstly you will need to connect power to your LoPy. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the LoPy via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the LoPy:\n\nBy default, when the LoPy boots, it will create a WiFi access point with the following credentials:\nSSID: lopy-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the LoPy. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nLora\nIf you intend on using the LoRa connectivity of the LoPy you must connect a LoRa antenna to your LoPy before trying to use LoRa otherwise you risk damaging the device.\n\nThe LoPy only supports LoRa on the 868MHz or 915MHz bands. It does not support 433MHz. For this you will require a LoPy4.\n\n\nFirstly you will need to connect the U.FL to SMA pig tail to the LoPy using the U.FL connector on the same side of the LoPy as the LED.\n\n\n\nIf you are using a pycase, you will next need to put the SMA connector through the antenna hole, ensuring you align the flat edge correctly, and screw down the connector using the provided nut.\nFinally you will need to screw on the antenna to the SMA connector.\n\n\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the LoPy, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the LoPy in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\nDeep Sleep current issue\nThe LoPy, SiPy, and WiPy 2.0 experience an issue where the modules maintain a high current consumption in deep sleep mode. This issue has been resolved in all newer products. The cause for this issue is the DC to DC switch mode converter remains in a high performance mode even when the device is in deep sleep. The flash memory chip also does not power down. A more detailed explanation can be found here.\n"},"gettingstarted/connection/lopy4.html":{"url":"gettingstarted/connection/lopy4.html","title":"LoPy 4","keywords":"","body":"LoPy 4\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWifiLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the LoPy4 module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the LoPy4 module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the LoPy4 module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\n Firstly you will need to connect power to your LoPy4. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the LoPy4 via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the LoPy4:\n\nBy default, when the LoPy4 boots, it will create a WiFi access point with the following credentials:\nSSID: lopy4-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the LoPy4. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nLora/Sigfox\nIf you intend on using the LoRa/Sigfox connectivity of the LoPy4 you must connect a LoRa/Sigfox antenna to your LoPy4 before trying to use LoRa/Sigfox otherwise you risk damaging the device.\n\n\nFirstly you will need to connect the U.FL to SMA pig tail to the LoPy4 using one of the two the U.FL connectors on the same side of the LoPy4 as the LED. The one on the left hand side is for 433MHz (LoRa only), the one of the right hand side is for 868MHz/915MHz (LoRa & Sigfox). Note: This is different from the LoPy.\n\n\n\nIf you are using a pycase, you will next need to put the SMA connector through the antenna hole, ensuring you align the flat edge correctly, and screw down the connector using the provided nut.\nFinally you will need to screw on the antenna to the SMA connector.\n\n\nSince the LoRa chip only runs on one frequency band at a time you only need to connect an antenna to the appropriate U.FL connecor. You should be supplied with a the antenna that suits the band you intend using.\n\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the LoPy4, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the LoPy4 in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\n"},"gettingstarted/connection/sipy.html":{"url":"gettingstarted/connection/sipy.html","title":"SiPy","keywords":"","body":"SiPy\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWiFiLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the SiPy module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the SiPy module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the SiPy module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\nFirstly you will need to connect power to your SiPy. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the SiPy via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the SiPy:\n\nBy default, when the SiPy boots, it will create a WiFi access point with the following credentials:\nSSID: sipy-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the SiPy. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nSigfox\nIf you intend on using the Sigfox connectivity of the SiPy you must connect a Sigfox antenna to your SiPy before trying to use Sigfox otherwise you risk damaging the device.\n\n\nFirstly you will need to connect the U.FL to SMA pig tail to the SiPy using the U.FL connector on the same side of the SiPy as the LED.\n\n\n\nIf you are using a pycase, you will next need to put the SMA connector through the antenna hole, ensuring you align the flat edge correctly, and screw down the connector using the provided nut.\nFinally you will need to screw on the antenna to the SMA connector.\n\n\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the FiPy, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the FiPy in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\nDeep Sleep current issue\nThe LoPy, SiPy, and WiPy 2.0 experience an issue where the modules maintain a high current consumption in deep sleep mode. This issue has been resolved in all newer products. The cause for this issue is the DC to DC switch mode converter remains in a high performance mode even when the device is in deep sleep. The flash memory chip also does not power down. A more detailed explanation can be found here.\n"},"gettingstarted/connection/gpy.html":{"url":"gettingstarted/connection/gpy.html","title":"GPy","keywords":"","body":"GPy\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWiFiLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the GPy module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the GPy module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the GPy module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\nFirstly you will need to connect power to your GPy. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the GPy via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the GPy:\n\nBy default, when the GPy boots, it will create a WiFi access point with the following credentials:\nSSID:gpy-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the GPy. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nLTE Cat-M1/NB-IoT\nIf you intend on using the LTE CAT-M1 or NB-IoT connectivity of the GPy you must connect a LTE CAT-M1/NB-IoT antenna to your GPy before trying to use LTE Cat-M1 or NB-IoT otherwise you risk damaging the device.\n\n\nYou will need to connect the antenna to the GPy using the U.FL connector on the same side of the GPy as the LED.\n\n\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the GPy, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the GPy in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\nSIM card \nIf you intend on using the LTE CAT-M1 or NB-IoT connectivity of the GPy you will need to insert a SIM card into your GPy. It should be noted that the GPy does not support regular LTE connectivity and you may require a special SIM. It is best to contact your local cellular providers for more information on acquiring a LTE CAT-M1/NB-IoT enabled nano SIM.\n\n"},"gettingstarted/connection/fipy.html":{"url":"gettingstarted/connection/fipy.html","title":"FiPy","keywords":"","body":"FiPy\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWiFiWhen using the expansion board with a FiPy, you will need to remove the CTS and RTS jumpers as these interfere with communication with the cellular modem.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the FiPy module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nWhen using the expansion board with a FiPy, you will need to remove the CTS and RTS jumpers as these interfere with communication with the cellular modem.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the FiPy module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the FiPy module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\nFirstly you will need to connect power to your FiPy. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the FiPy via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the FiPy:\n\nBy default, when the FiPy boots, it will create a WiFi access point with the following credentials:\nSSID: fipy-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the FiPy. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nLora/Sigfox\nIf you intend on using the LoRa/Sigfox connectivity of the FiPy you must connect a LoRa/Sigfox antenna to your FiPy before trying to use LoRa/Sigfox otherwise you risk damaging the device.\n\nThe FiPy only supports LoRa on the 868MHz or 915MHz bands. It does not support 433MHz. For this you will require a LoPy4.\n\n\nFirstly you will need to connect the U.FL to SMA pig tail to the FiPy using the U.FL connector on the same side of the FiPy as the LED.\n\n\n\nIf you are using a pycase, you will next need to put the SMA connector through the antenna hole, ensuring you align the flat edge correctly, and screw down the connector using the provided nut.\nFinally you will need to screw on the antenna to the SMA connector.\n\n\nLTE Cat-M1/NB-IoT\nIf you intend on using the LTE CAT-M1 or NB-IoT connectivity of the FiPy you must connect a LTE CAT-M1/NB-IoT antenna to your FiPy before trying to use LTE Cat-M1 or NB-IoT otherwise you risk damaging the device.\n\n\nYou will need to connect the antenna to the FiPy using the U.FL connector on the under side of the FiPy.\n\n\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the FiPy, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the FiPy in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\nSIM card \nIf you intend on using the LTE CAT-M1 or NB-IoT connectivity of the FiPy you will need to insert a SIM card into your FiPy. It should be noted that the FiPy does not support regular LTE connectivity and you may require a special SIM. It is best to contact your local cellular providers for more information on acquiring a LTE CAT-M1/NB-IoT enabled nano SIM.\n\n"},"gettingstarted/connection/wipy.html":{"url":"gettingstarted/connection/wipy.html","title":"WiPy","keywords":"","body":"WiPy\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWiFiLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the WiPy module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the WiPy module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the WiPy module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\nFirstly you will need to connect power to your WiPy. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the WiPy via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the WiPy:\n\nBy default, when the WiPy boots, it will create a WiFi access point with the following credentials:\nSSID: wipy-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the WiPy. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the WiPy, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the WiPy in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\nDeep Sleep current issue\nThe LoPy, SiPy, and WiPy 2.0 experience an issue where the modules maintain a high current consumption in deep sleep mode. This issue has been resolved in all newer products. The cause for this issue is the DC to DC switch mode converter remains in a high performance mode even when the device is in deep sleep. The flash memory chip also does not power down. A more detailed explanation can be found here.\nWiPy 2.0 vs WiPy 3.0\nThe WiPy 3.0 is an upgraded version of the WiPy 2.0 with the following changes:\n\nThe FLASH has been upgraded from 4MB to 8MB.\nThe RAM has been upgraded from 512KB to 4MB.\nThe deepsleep current consumption issue has been fixed\nThe antenna select pin has moved to GPIO21 (P12)\n\n"},"gettingstarted/installation/":{"url":"gettingstarted/installation/","title":"Software","keywords":"","body":"Software\nTo get you up and running, Pycom provides a suite of tools to assist with developing and programming your Pycom Devices:\n\nDrivers: If you are using Microsoft Windows, you might be required to install drivers for our products to function correctly.\nPycom firmware update utility: This tool automates the process of upgrading the firmware of your Pycom device. It is important that you use this tool before you attempt to use your device. Not only to ensure you have the most stable and feature packed firmware, but also to ensure all the functionality of your device is enable. E.g. this tool also activates your two year free sigfox connectivity.\nDevelopment Environment: Pymakr is a plug-in for Atom and Visual Studio Code developed by Pycom to make development for Pycom modules super easy. It allows you to use your favourite text editor while simplifying the process of uploading code to the device.\n\n"},"gettingstarted/installation/drivers.html":{"url":"gettingstarted/installation/drivers.html","title":"Drivers","keywords":"","body":"Drivers\nLinux\nYou should not need to install any drivers for our devices to be recognised by Linux. You may how ever need to adjust permissions to make sure you have access to the serial port. On most distributions this can be done by adding your user to the dialout user group. Please check the specific instructions for your linux distribution for how to do this.\nmacOS\nOn macOS you shouldn't need to do anything special to get our device to work.\nWindows\nAll our products will work out of the box for Windows 8/10/+. If using Windows 7, drivers to support the Pysense/Pytrack/Pyscan/Expansion Board 3.0 boards will need to be installed.\nDownload\nPlease download the driver software from the link below.\nPysense/Pytrack/Pyscan/Expansion Board 3.0 Serial Driver (save the file to your computer)\nInstallation\nFirst navigate open the Windows start menu and search/navigate to `Device Manager. You should see your Pytrack/Pysense in the dropdown under other devices.\n\nRight click the device and select Update Driver Software.\n\nSelect the option to Browse my computer for driver software.\n\nNext you will need to navigate to where you downloaded the driver to (e.g. Downloads Folder).\n\nSpecify the folder in which the drivers are contained. If you haven't extracted the .zip file, please do this before selecting the folder.\n\nYou may receive a warning, suggesting that Windows can't verify the publisher of this driver. Click Install this driver software anyway as this link points to our official driver.\n\nIf the installation was successful, you should now see a window specifying that the driver was correctly installed.\n\nTo confirm that the installation was correct, navigate back to the Device Manager and click the dropdown for other devices. The warning label should now be gone and Pytrack/Pysense should be installed.\n\n"},"gettingstarted/installation/firmwaretool.html":{"url":"gettingstarted/installation/firmwaretool.html","title":"Updating Firmware","keywords":"","body":"Updating Firmware\nWe strongly recommend you to upgrade your firmware to the latest version as we are constantly making improvements and adding new features to the devices.\nHere are the download links to the update tool. Please download the appropriate one for your OS and follow the instructions on the screen.\n\nWindows\nmacOS (10.11 or Higher)\nLinux (requires dialog and python-serial package)\n\nPrevious versions of firmware are available for download here.\n\nUpdating Device Firmware\nThe basic firmware upgrade procedure can be found below, please follow these steps carefully:\nAfter you're done with upgrading, you can use the Pymakr Plugins to upload and run programs in your device.\nExp Board 2.0Exp Board 3.0Disconnect your device from your computer\n\nInsert module into the Expansion Board\n\nConnect a jumper cable or wire between G23 and GND\n\nReconnect the board via USB to your computer, this puts the device in ‘firmware update mode'.\n\nRun the Firmware Upgrade tool\n\nRemove the G23 to GND jumper cable/wire\nReboot the device (button or power off then on), your device is now ready to use\nIf you are having any issues, make sure the TX and RX jumpers are present on your Expansion Board, as the jumpers sometimes come loose in the box during transport. Without these jumpers, the updater will fail.\nAfter you're done with upgrading, you can use the Pymakr Plugins to upload and run programs in your device.\n"},"gettingstarted/installation/pymakr.html":{"url":"gettingstarted/installation/pymakr.html","title":"Pymakr","keywords":"","body":"Pymakr\n\nPymakr Plugins \nTo make it as easy as possible Pycom has developed a plugin for two popular text editors, called Pymakr. These plugins have been built and are available for the following platforms:\n"},"gettingstarted/programming/":{"url":"gettingstarted/programming/","title":"Programming the modules","keywords":"","body":"Programming the modules\nNow that you have connected and updated your pycom module and installed all the required software on your computer, we can begin programming your Pycom module.\nIf this is your first time using a Pycom module we highly recommend you read through the following pages:\n\nIntroduction to MicroPython: This page will explain what Micropython is and its relation to Python.\nMicroPython Examples: We also recommend you browse these short MicroPython examples to familiarise yourself with its syntax. This is not meant as a comprehensive guide to MicroPython programming but rather a reference to those who already know programming. If you are new to python, or programming all together, we highly recommend searching the internet for Python tutorials. There are many very good tutorials available for free and the skills you learn will be easily transferable to our platform.\nYour first Pymakr project: Once you understand what MicroPython is, this guide will take you through setting up your first Pymakr project to blink the on-board RGB LED. This guide will explain the structure of a MicroPython project as well as how to upload it to your module.\n\nOnce you are familiar with MicroPython and Pymakr, the recommended way of uploading code to your module, you can explore the pages below. These will discuss in greater detail the various mechanisms for running code on your device as well as how to recover it if something goes wrong.\n\nREPL: The REPL (Read Evaluate Print Loop) is an interactive terminal that allows you to type in and test your code directly on the device, just like interactive python interpreter. It can be accessed via UART or Telnet. This is accessed easiest by using Pymakr but if you wish to use other tools, this page will explain how.\nFTP: All Pycom modules start up with a WiFi access point enabled, and a simple FTP server running on it. Once connected to the WiFi network, you can use FTP to transfer files over to your device wirelessly. This can be very useful if you do not have physical access to your device.\nSafe Boot: It is possible that some code you upload to your module will prevent you accessing the REPL or FTP server, preventing you from updating your scripts. This guide will detail how to safe boot your module and how to remove the offending scripts from it.\n\n"},"gettingstarted/programming/micropython.html":{"url":"gettingstarted/programming/micropython.html","title":"Introduction to MicroPython","keywords":"","body":"Introduction to MicroPython\nOur boards work with MicroPython; a Python 3.5 implementation that is optimised to run on micro controllers. This allows for much faster and more simple development process than using C.\n\nBooting into MicroPython\nWhen booting, two files are executed automatically: first boot.py and then main.py. These are placed in the /flash folder on the board. Any other files or libraries can be placed here as well, and can be included or used from boot.py or main.py.\nThe folder structure in /flash looks like the picture below. The files can be managed either using FTP or using the Pymakr Plugin.\n\nTips & Tricks\nMicropython shares majority of the same syntax as Python 3.5. The intention of this design is to provide compatibility upwards from Micropython to Python 3.5, meaning that code written for Micropython should work in a similar manner in Python 3.5. There are some minor variations and these should taken viewed as implementation differences.\nMicropython also has a number of Micropython specific libraries for accessing hardware level features. Specifics relating to those libraries can be found in the Firmware API Reference section of this documentation.\nMicropython, unlike C/C++ or Arduino, does not use braces {} to indicate blocks of code specified for class and function definitions or flow control. Blocks of code are denoted by line indentation, which is strictly enforced.\nThe number of spaces in the indentation is variable but all statements within a block must be indented the same amount.\n\n"},"gettingstarted/programming/examples.html":{"url":"gettingstarted/programming/examples.html","title":"MicroPython Examples","keywords":"","body":"MicroPython Examples\nTo get you started with Python (MicroPython) syntax, we've provided you with a number of code examples.\nVariable Assignment\nAs with Python 3.5, variables can be assigned to and referenced. Below is an example of setting a variable equal to a string and then printing it to the console.\nvariable = \"Hello World\"\nprint(variable)\n\nConditional Statements\nConditional statements allow control over which elements of code run depending on specific cases. The example below shows how a temperature sensor might be implemented in code.\ntemperature = 15\ntarget = 10\nif temperature > target:\n print(\"Too High!\")\nelif temperature \nLoops (For & While loop)\nLoops are another important feature of any programming language. This allows you to cycle your code and repeat functions/assignments/etc.\nfor loops allow you to control how many times a block of code runs for within a range.\nx = 0\nfor y in range(0, 9):\n x += 1\nprint(x)\n\nwhile loops are similar to for loops, however they allow you to run a loop until a specific conditional is true/false. In this case, the loop checks if x is less than 9 each time the loop passes.\nx = 0\nwhile x \nFunctions\nFunctions are blocks of code that are referred to by name. Data can be passed into it to be operated on (i.e. the parameters) and can optionally return data (the return value). All data that is passed to a function is explicitly passed.\nThe function below takes two numbers and adds them together, outputting the result.\ndef add(number1, number2):\n return number1 + number2\n\nadd(1, 2) # expect a result of 3\n\nThe next function takes an input name and returns a string containing a welcome phrase.\ndef welcome(name):\n welcome_phrase = \"Hello, \" + name + \"!\"\n print(welcome_phrase)\n\nwelcome(\"Alex\") # expect \"Hello, Alex!\"\n\nData Structures\nPython has a number of different data structures for storing and manipulating variables. The main difference (regarding data structures) between C and Python is that Python manages memory for you. This means there's no need to declare the sizes of lists, dictionaries, strings, etc.\nLists\nA data structure that holds an ordered collection (sequence) of items.\nnetworks = ['lora', 'sigfox', 'wifi', 'bluetooth', 'lte-m']\nprint(networks[2]) # expect 'wifi'\n\nDictionaries\nA dictionary is like an address-book where you can find the address or contact details of a person by knowing only his/her name, i.e. keys (names) are associate with values (details).\naddress_book = {'Alex':'2604 Crosswind Drive','Joe':'1301 Hillview Drive','Chris':'3236 Goldleaf Lane'}\nprint(address_book['Alex']) # expect '2604 Crosswind Drive'\n\nTuple\nSimilar to lists but are immutable, i.e. you cannot modify tuples after instantiation.\npycom_devices = ('wipy', 'lopy', 'sipy', 'gpy', 'fipy')\nprint(pycom_devices[0]) # expect 'wipy'\n\nFor more Python examples, check out these tutorials. Be aware of the implementation differences between MicroPython and Python 3.5.\n\n"},"gettingstarted/programming/first-project.html":{"url":"gettingstarted/programming/first-project.html","title":"Your first Pymakr project","keywords":"","body":"Your first Pymakr project\nThis guide will take you through how to setup your first project with Pymakr and make the on-board RGB LED flash various colours.\nCreating a project in Pymakr\n\nFirstly you will need to create a new, empty, directory on your computer.\nFor this example we will create one called RGB-Blink.\n\nNext you will need to open either Atom or Visual Studio Code depending on\nwhich you setup previously.\n\nOnce the text editor has loaded you will need to click File > Open, and open the directory you created in step 1\n\n\nIf you are using Atom, it is important to check at this point that Atom has successfully identified the project. The name of the directory you created in step 1 (RGB-Blink in this case) should be shown in the Pymakr pane like so:\n\nIf this is not the case you can press alt-ctrl-r on Windows/Linux or ctrl-alt-cmd-l on macOS, in order to reload Atom and fix the issue.\n\n\nNow that you have a project created, we need to add some files to it. A standard MicroPython project has the following structure:\n\nRGB-Blink\n|-lib\n| |- some_library.py\n|-boot.py\n|-main.py\n\n\nboot.py This is the first script that runs on your module when it\nturns on. This is often used to connect a module a a WiFi network so that\nTelnet and FTP can be used without connecting to the WiFi AP created by the\nmodule and not cluttering up the main.py file. As a beginner you do not\nneed to use a boot.py.\n\nmain.py This script runs directly after boot.py and should contain\nthe main code you wish to run on your device.\n\nlib It is often a good idea to split out re-usable code into libraries.\nIf you want to create or use libraries created by others, you will need to\ncreate a lib directory and put the library files in this. It is important\nthat you put .py files directly into lib rather than creating a directory\ntree. By default MicroPython will not detect any libraries within\nsub-directories.\n\n\nFor this example, you will just need to create a main.py file.\nNow that the project structure is setup, you may wish to configure project specific settings for Pymakr e.g. Which serial port to use. On Atom you need to click the ^ button on the Pymakr pane, then click Project Settings. On Visual Studio Code you need to click the All commands button on the bottom of the windows, then click Pymakr > Project Settings. This creates a file called pymakr.conf inside your project and populates it with default settings copied over from your global settings. A detailed explanation of these settings can be found here.\nControlling the on-board LED\nNow that you have setup and configured your project, we can move on to programming your module. The first thing we will need to do is import some libraries in order to interact with the on-board LED. The Pycom firmware comes with a large amount of libraries for standard functionality built-in. You can find out more about these in the API documentation. For this example you will need to open the main.py file and add the following code:\nimport pycom\nimport time\n\nThis will import two libraries, Pycom which is responsible for Pycom specific features, such as the on-board LED and time which is a standard library used timing and delays.\nYou may have noticed that when you power up your Pycom module, the on-board LED blinks blue on a regular basis. This \"heartbeat\" is used as a way of know that your module has powered up and started correctly. Before we can change the colour of this LED we need to disable this heart beat. Below your imports you will need to add the following:\npycom.heartbeat(False)\n\nNow it's time to test your code. On the Pymakr pane/bottom of the window you will see a run button. (If you haven't connected to your device yet, you will need to do that first). When you click the run button, the code in the currently open file will be executed on the device, but it won't copy it to the device. After running this code, you should see that that on-board LED stops blinking blue.\nNow that we can confirm the device is connected and Pymakr is able to run code on it, we can complete our script to blink the LED like so:\nimport pycom\nimport time\n\npycom.heartbeat(False)\n\nwhile True:\n pycom.rgbled(0xFF0000) # Red\n time.sleep(1)\n pycom.rgbled(0x00FF00) # Green\n time.sleep(1)\n pycom.rgbled(0x0000FF) # Blue\n time.sleep(1)\n\nOnce you run the above script, it will run forever. You will notice this prevents you from accessing the interactive REPL on the device (You cannot see the >>> prompt). In order to stop the script, click onto the Pymakr terminal, and press ctrl-c on your keyboard. This should stop the script running and return you to the interactive REPL.\nUploading to your module\nIn the previous section we got code running on on your Pycom module using the run feature of Pymakr. This is useful for quick testing but has a couple of drawbacks. Firstly the code does not remain on the device permanently. If you reboot the device, it will no longer be running your code. Secondly, it will only work if you are using libraries built into the firmware. If you need any extra libraries, these need to be copied to the device first. This is where the upload feature comes in. If instead of run you click upload, Pymakr will upload all the files in the project (so long as their type is in the sync_file_types setting for your project). These then persist on your device even between reboots, and allows you to use libraries from the lib folder in your project.\nIf you need to remove files from your device you have two options, either connect via FTP and manage your files that way or format the device's internal flash like so:\nimport os\nos.mkfs('/flash')\n\n"},"gettingstarted/programming/repl/":{"url":"gettingstarted/programming/repl/","title":"REPL","keywords":"","body":"REPL\nREPL stands for Read Evaluate Print Loop, and is the name given to the interactive MicroPython prompt that is accessible on the Pycom devices. Using the REPL is by far the easiest way to test out Python code and run commands. You can use the REPL in addition to writing scripts in main.py.\nThe following pages will explain how to use the REPL with both Serial USB and Telnet connections.\nThe REPL includes the following features:\n\nInput history: use arrow up and arrow down to scroll through the history\nTab completion: press tab to auto-complete variables or module names\nHalt any executing code: with Ctrl-C\nCopy/paste code or output: Ctrl-C and Ctrl-V\n\nThere are a number of useful shortcuts for interacting with the MicroPython REPL. See below for the key combinations;\n\nCtrl-A on a blank line will enter raw REPL mode. This is similar to permanent paste mode, except that characters are not echoed back.\nCtrl-B on a blank like goes to normal REPL mode.\nCtrl-C cancels any input, or interrupts the currently running code.\nCtrl-D on a blank line will do a soft reset.\nCtrl-E enters ‘paste mode' that allows you to copy and paste chunks of text. Exit this mode using Ctrl-D.\nCtrl-F performs a \"safe-boot\" of the device that prevents boot.py and main.py from executing\n\n\n"},"gettingstarted/programming/repl/serial.html":{"url":"gettingstarted/programming/repl/serial.html","title":"Serial USB (UART)","keywords":"","body":"Serial USB (UART)\nTo use the REPL, a Pycom device must be connected to the host computer with a USB connection either to an Expansion Board or to serial converter (a diagram of how to do this can be found the the getting started page for your module).\nIn order to connect to the REPL over USB serial, there are multiple methods. Detailed below are the explanations of how to do it in MacOS, Linux and Windows.\nAll platforms\nBy far the easiest way to access the USB UART REPL is via the our Pymakr plug-in for Atom and Visual Studio Code. This adds a pane to the bottom of the editors that allows you to directly access the REPL and any output from the device. Detailed instructions on how to setup Pymakr can be found here.\nmacOS and Linux\nTo open a serial USB connection from macOS, any serial tool may be used; in this example, the terminal tool screen will be used.\nOpen a terminal instance and run the following commands:\n$ screen /dev/tty.usbmodem* 115200\n\nUpon exiting screen, press CTRL-A CTRL-\\. If the keyboard does not support the \\-key (i.e. an obscure combination for \\ like ALT-SHIFT-7 is required), the key combination can be remapped for the quit command:\n\ncreate ~/.screenrc\nadd bind q to the exit command\n\nThis will allow screen to exited by pressing CTRL-A Q.\nOn Linux, picocom or minicom may be used instead of screen. The usb serial address might also be listed as /dev/ttyUSB01 or a higher increment for ttyUSB. Additionally, the elevated permissions to access the device (e.g. group uucp/dialout or use sudo) may be required.\n\nWindows\nA terminal emulator is needed to open the connection from Windows; the easiest option is to download the free program, PuTTY.\nCOM Port\nTo use PuTTY the serial port (COM port) in which the Pycom device is connected, must be located. In Windows, this information can be found from the 'Device Manager' program.\n\nOpen the Windows start menu and search for 'Device Manager'\nThe COM port for the Pycom device will be listed as 'USB Serial Device' or a similar name\nCopy/Write down the associated COM port (e.g. COM4)\n\nUsing Putty\n\nWith PuTTY open, click on Session in the left-hand panel\nNext click the Serial radio button on the right and enter the associated\nCOM port (e.g. COM4) in the Serial Line box\n\nFinally, click the Open button\n\n\n\n"},"gettingstarted/programming/repl/telnet.html":{"url":"gettingstarted/programming/repl/telnet.html","title":"Telnet REPL","keywords":"","body":"Telnet REPL\nPycom devices also support a connection via telnet, using the device's on board WiFi/WLAN. Connect to the device's WiFi Access Point (AP) and using the following credentials to connect to the AP. The WiFi SSID will appear upon powering on a Pycom Device for the first time (e.g. lopy-). To re-enable this feature at a later date, please see network.WLAN.\n\npassword: www.pycom.io\n\nTelnet Server\nAdditionally, to use the MircoPython REPL over telnet, further authentication is required. The default credentials for the telnet server are:\n\nusername: micro\npassword: python\n\nSee network.server for info on how to change the default authentication.\nAll platforms\nBy far the easiest way to access the Telnet REPL is via the our Pymakr plug-in for Atom and Visual Studio Code. This adds a pane to the bottom of the editors that allows you to directly access the REPL and any output from the device. Detailed instructions on how to setup Pymakr can be found here.\nmacOS and Linux\nOnce the host machine is connected to the Pycom device's Access Point, a telnet connection may be opened from a terminal instance.\n$ telnet 192.168.4.1\n\nUpon connection, the telnet program will prompt for the username and password in the section above.\nWindows\nA terminal emulator is needed to open a telnet connection from Windows; the easiest option is to download the free program, PuTTY.\n\nWith PuTTY open, select telnet as connection type and leave the default port (23)\nNext enter the IP address of the Pycom device (e.g. 192.168.4.1)\nFinally click Open\n\nWhen using a Pycom device with a personal, home or office WiFi access point, the telnet connection may still be used. In this instance, the user will need to determine the Pycom device's local IP address and substitute this for 192.168.4.1, referred to in the earlier sections.\n\n"},"gettingstarted/programming/ftp.html":{"url":"gettingstarted/programming/ftp.html","title":"FTP","keywords":"","body":"FTP\nThere is a small internal file system accessible with each Pycom device, called /flash. This is stored within the external serial flash memory. If a microSD card is also connected and mounted, it will be available as well. When the device starts up, it will always boot from the boot.py located in the /flash file system.\nThe file system is accessible via the native FTP server running on each Pycom device. Open an FTP client and connect to:\n\nurl: ftp://192.168.4.1\nusername: micro\npassword: python\n\nSee network.server for information on how to change the defaults. The recommended clients are:\n\nmacOS/Linux: default FTP client\nWindows: Filezilla and FireFTP\n\nFor example, from a macOS/Linux terminal:\n$ ftp 192.168.4.1\n\nThe FTP server doesn't support active mode, only passive mode. Therefore, if using the native unix FTP client, immediately after logging in, run the following command:\nftp> passive\n\nThe FTP server only supports one connection at a time. If using other FTP clients, please check their documentation for how to limit the maximum allowed connections to one at a time.\nFileZilla\nIf using FileZilla, it's important to configure the settings correctly.\nDo not use the quick connect button. Instead, open the site manager and create a new configuration. Within the General tab, ensure that encryption is set to: Only use plain FTP (insecure).\n\nIn the Transfer Settings tab, limit the max number of connections to one. Other FTP clients may behave in a similar ways; visit their documentation for more specific information.\n\n"},"gettingstarted/programming/safeboot.html":{"url":"gettingstarted/programming/safeboot.html","title":"Safe boot","keywords":"","body":"Safe boot\nIf powering up normally or upon pressing the reset button, a Pycom module will boot into standard mode; the boot.py file will be executed first, followed by main.py. It is possible to alter the boot procedure of the module by tying certain pins high or low when the module boots.\nBootloader\nIf you updated your device before using it, you have already put the device into bootloader mode. This is achieved by connecting G23 to GND while the device boots. If you used a Pysense/Pytrack to update, it did this automatically for you. You only need to put your Pycom module into bootloader mode if you are updating its firmware, or are programming your own low level code. This is not required if you are updating your MicroPython code.\nSafe Boot\nSome times the code you have written will prevent you gaining access to the REPL or prevent you updating your code. Some example may be:\n\nYou disabled the WiFi/UART\nYour code gets stuck before reaching the REPL\nYou set a socket as blocking but never receive any data\n\nIn order to fix this you can safe boot your module. This will prevent boot.py and main.py from being executed and will drop you straight into the interactive REPL. After reset, if P12 pin is held high (i.e. connect it to the 3V3 output pin), the heartbeat LED will begin flashing orange slowly. If after 3 seconds the pin is still held high, the LED will start blinking faster. In this mode the module will do the same as previously explained but it will also select the previous OTA image to boot if you have updated the module via the OTA update procedure (updates performed via the firmware update tool do not count). This is useful if you flashed a OTA update that breaks the device.\nPin P12 released during:\n\n\n\n1st 3 secs window\n2nd 3 secs window\n\n\n\n\nDisable boot.py and main.py\nSame as previous but using previous OTA firmware\n\n\n\nThe selection made during safe boot is not persistent, therefore after the next normal reset, the latest firmware will proceed to run again.\nIf problems occur within the filesystem or you wish to factory reset your module to remove your code, run following code in the REPL:\n>>> import os\n>>> os.mkfs('/flash')\n\nBe aware, resetting the flash filesystem will delete all files inside the internal device storage (not the SD card) and they cannot be recovered.\n\nReset\nPycom devices support both soft and hard resets. A soft reset clears the state of the MicroPython virtual machine but leaves hardware peripherals unaffected. To do a soft reset, press Ctrl+D on the REPL or from within a script, run:\n>>> import sys\n>>> sys.exit()\n\nA hard reset is the same as performing a power cycle to the device. In order to hard reset the device, press the reset switch or run:\n>>> import machine\n>>> machine.reset()\n\n"},"gettingstarted/registration/":{"url":"gettingstarted/registration/","title":"Device Registration","keywords":"","body":"Device Registration\nSome of our devices require registration before you can utilise specific features such as certain types of networking. Please see the list below for setup guides to ensure that your device is registered and activated on the various platforms required to access all of the available features.\n\n\n\n\nNot all Pycom devices require activation; most features work immediately out of the box!\n\n"},"gettingstarted/registration/sigfox.html":{"url":"gettingstarted/registration/sigfox.html","title":"Sigfox","keywords":"","body":"Sigfox\nBefore you start, update your device to the latest firmware. Select stable firmware in Firmware updater. After firmware update is done, Sigfox ID and Sigfox PAC were assigned to your device.\nCopy Sigfox ID and Sigfox PAC from the last screen of firmware updater.\n\nSigfox ID and Sigfox Pac is assigned to your device just once during the first update process. Sigfox ID and Sigfox Pac will not change after successive firmware updates.\nAfter first firmware update you can also get your Sigfox ID and Sigfox PAC through a couple of commands via the REPL.\nfrom network import Sigfox\nimport binascii\n\n# initalise Sigfox for RCZ1 (You may need a different RCZ Region)\nsigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)\n\n# print Sigfox Device ID\nprint(binascii.hexlify(sigfox.id()))\n\n# print Sigfox PAC number\nprint(binascii.hexlify(sigfox.pac()))\n\nCreating account at Sigfox backend\nYou need to register to the Sigfox Backend. Navigate to https://backend.sigfox.com/activate\n\nFind the specific country country where the device will be activated. Enter the device's Sigfox ID and Sigfox PAC.\nYou should see green microchip if you entered correct Sigfox ID and Sigfox PAC\n\nThen provide the required information including email address and complete registration.\nWhen registering your other devices (not your first device), you already have created Sigfox Account before. Be sure you are login with your Sigfox account. In that way all of your devices will be added to same Sigfox Account.\n\n\nAfter registration, you will receive confirmation email with password to Sigfox backend https://backend.sigfox.com/auth/login\nUse your email and password to login to Sigfox backend.\n\nIf you enter correct credentials then you should be able to login to Sigfox backend.\nTransferring your device to new Sigfox account\nYou may want to transfer your devices to new Sigfox account.\nOnce you register your device on Sigfox backend, then your Sigfox PAC was used, and is not valid anymore. You need to get new Sigfox PAC. We don't update Sigfox PAC assigned to your device (which can be seen on last page of Firmware updater or read from device).\nTo get new Sigfox PAC navigate to your device on Sigfox backend. On device click on Sigfox Id of device you want to transfer.\n\nNow you can see your new Sigfox PAC.\n\nOnce you know your new Sigfox PAC go to https://backend.sigfox.com/activate and register device with different account.\n"},"gettingstarted/registration/cellular.html":{"url":"gettingstarted/registration/cellular.html","title":"Cellular","keywords":"","body":"Cellular\nIn order to use your GPy/FiPy on a cellular network you are required to get a SIM card from a local provider.\nNote: This might differ from a standard SIM you can buy in a store, our devices do not support standard LTE.\nCurrently we are not able to provide any specific details about how to get such a SIM card and how to register it as most deployments are closed trials, each carrier has it's own rules (for example, whether they require special SIMs or not).\nWe recommend contacting your local cellular providers to check their plans surrounding LTE CAT-M1 and NB-IoT. By contacting them, you will show the carriers that there is local interest in deploying such networks.\nYou can find a map of deployed networks and open labs here.\n"},"gettingstarted/registration/lora/":{"url":"gettingstarted/registration/lora/","title":"LoRaWAN","keywords":"","body":"LoRaWAN\nRaw LoRa\nWhen using raw LoRa, you do not have to register your module in any way. The modules can talk to each other directly.\nLoRaWAN\nIn order to connect your LoRa capable Pycom module to a LoRaWAN network you will have to register your device with the desired network. We are unable to provide instructions for all LoRaWAN networks but below you will find some generic instructions, along with links to any specific guides we are aware of.\nGeneric instructions\nFirstly you will need to get your modules Device EUI, this can be achieved using the following code:\nfrom network import LoRa\nimport ubinascii\n\nlora = LoRa(mode=LoRa.LORAWAN)\nprint(ubinascii.hexlify(lora.mac()).upper().decode('utf-8'))\n\nThe output will be a hex string like: 70B3D5499585FCA1. Once you have this you will need to provide it to your LoRaWAN network which will then provide you with the details need to connect via Over-the-Air Activation (OTAA) or Activation by Personalisation (ABP)\nOTAA\nIf you wish to connect via OTAA (which is the recommended method) the network will provide you with an Application EUI and Application Key. The former identifies what application your device is connecting to, the latter is a shared secret key unique to your device to generate the session keys that prove its identity to the network. Once you have these you can use the LoRaWAN OTAA example code to connect to the network.\nABP\nWith ABP the encryption keys enabling communication with the network are preconfigured in the device. The network will need to provide you with a Device Address, Network Session Key and Application Session Key. Once you have these you can use the LoRaWAN ABP example code to connect to the network.\nNetworks\n\n\nIf you cannot find your favourite LoRaWAN network in the list above, please consider writing a tutorial for how to connect a Pycom module with it and contribute it to this documentation via a GitHub pull request.\n\n"},"gettingstarted/registration/lora/ttn.html":{"url":"gettingstarted/registration/lora/ttn.html","title":"The Things Network","keywords":"","body":"The Things Network\nIn order to use The Things Network (TTN) you should navigate to their website and create/register an account. Enter a username and an email address to verify with their platform.\n\nOnce an account has been registered, you can register your Pycom module as either a node or a nano-gateway. The steps below will detail how to do this.\nCreate an application\nIn order to register your device to connect to the things network, you must first create an application for these devices to belong to. This way the Network will know where to send the devices data to.\nSelecting the Applications tab at the top of the TTN console, will bring up a screen for registering applications. Click register and a new page, similar to the one below, will open.\n\nEnter a unique Application ID as well as a Description & Handler Registration.\nNow the Pycom module nodes can be registered to send data up to the new Application.\nRegister a Device\nTo connect nodes to a things network gateway, devices need to be added to the application. To do this, navigate to the Devices tab on the Application home page and click the Register Device button.\n\nIn the Register Device panel, complete the forms for the Device ID and the Device EUI. The Device ID is user specified and is unique to the device in this application. The Device EUI should be a globally unique identifier for the device. You can run the following on you Pycom module to retrieve its EUI.\nfrom network import LoRa\nimport ubinascii\n\nlora = LoRa()\nprint(\"DevEUI: %s\" % (ubinascii.hexlify(lora.mac()).decode('ascii')))\n\nOnce the device has been added, change the Activation Method between OTAA and ABP depending on user preference. This option can be found under the Settings tab.\nRegister a Nano-Gateway\nYou can also setup your Pycom module to act as a gateway with The Things Network. The code required to do this can be found here.\nInside the TTN Console, there are two options, Applications and Gateways. Select Gateways and then click on register Gateway. This will allow for the set up and registration of a new nano-gateway.\n\nOn the Register Gateway page, you will need to set the following settings:\n\nThese are unique to each gateway, location and country specific frequency. Please verify that correct settings are selected otherwise the gateway will not connect to TTN.\nYou need to tick the \"I'm using the legacy packet forwarder\" to enable the right settings. This is because the Nano-Gateway uses the 'de facto' standard Semtech UDP protocol.\n\n\n\nOption\nValue\n\n\n\n\nProtocol\nPacket Forwarder\n\n\nGateway EUI\nUser Defined (must match config.py)\n\n\nDescription\nUser Defined\n\n\nFrequency Plan\nSelect Country (e.g. EU - 868 MHz)\n\n\nLocation\nUser Defined\n\n\nAntenna Placement\nIndoor or Outdoor\n\n\n\nMost LoRaWAN network servers expect a Gateway ID in the form of a unique 64-bit hexadecimal number (called a EUI-64). The recommended practice is to produce this ID from your board by expanding the WiFi MAC address (a 48-bit number, called MAC-48). You can obtain that by running this code prior to configuration:\n from network import WLAN\n import binascii\n wl = WLAN()\n binascii.hexlify(wl.mac())[:6] + 'FFFE' + binascii.hexlify(wl.mac())[6:]\n\nOnce these settings have been applied, click Register Gateway. A Gateway Overview page will appear, with the configuration settings showing. Next click on the Gateway Settings and configure the Router address to match that of the gateway (default: router.eu.thethings.network).\n\nThe Gateway should now be configured.\n"},"gettingstarted/registration/lora/senet.html":{"url":"gettingstarted/registration/lora/senet.html","title":"Senet","keywords":"","body":"Senet\n\nThe Senet Developer Portal\nConnecting your device begins by creating an account on the Senet Developer Portal. This will grant you free access for up to 10 devices and 5 gateways to support application development activities. Sign-Up\nComplete Senet Developer Portal documentation is available on line at Docs.\nOnce your account has been activated, you may want to onboard a gateway, if Senet public network access in unavailable. Onboarding your device consists of registering the device through your portal account and then provisioning your device with the information provided at the completion of the registration process. Senet supports both Over-The-Air-Activation (OTAA) and Activation-By-Personalization (ABP). As ABP is useful only in a very narrow set of use-cases, this tutorial will walk you through OTAA registration and provisioning.\nDevice Identity and Security Elements\nAll LoRaWAN 1.0.x end-devices require three provisioning elements to join a network. Devices typically come from the factory with a unique, 64-bit EUI (called a DevEUI) which is the device's globally unique identifier. In the case of the Senet Developer Portal, the two additional elements (The Application EUI or AppEUI and Application Key or AppKey) will be generated and provided to you after registration (in typical production environments, these additional elements are also provided during manufacturing and provisioned into the network backend).\n\nDevice EUI (DevEUI)\nApplication EUI (AppEUI)\nApplication Key (AppKey)\n\nDevice EUI\nThis comes from the device itself and can be obtained from lora.mac().To obtain the required hexadecimal representation you can run the following code on your LoPy:\nfrom network import LoRa\nimport ubinascii\n\nlora = LoRa()\nprint(\"DevEUI: %s\" % (ubinascii.hexlify(lora.mac()).decode('ascii')))\n\nUse this value during the first step of device registration.\n\nApplication EUI and Application Key\nThe Application EUI uniquely identifies the security broker (called a Join Server in LoRaWAN terminology) which is interogated by the network when the device attempts to join the network. The Application Key is the shared secret (between the end-device and the Join-Server) which forms the basis for LoRaWAN security and is used to generate the application and network session keys used for privacy and message integrity.\nAt the completion of your device registration process on the Senet Developer Portal, you will be presented with the Application EUI and the Application Key which you will need to provision in your device. This information is always available after the fact in the device details screen.\n\nProvisioning the LoPy or FiPy\nAfter device registration is complete, configure the device for optimal operation and provision the AppEUI and AppKey.\nfrom network import LoRa\nimport socket\nimport time\nimport ubinascii\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.US915)\n\n# create an OTAA authentication parameters\napp_eui = ubinascii.unhexlify('00250C0000010001')\napp_key = ubinascii.unhexlify('00112233445566778899AABBCCDDEEFF')\n\n# initialize LoRa\nlora.init(mode=LoRa.LORAWAN, adr=True, public=True)\n\n# join a network using OTAA (Over the Air Activation)\nlora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), dr=0, timeout=0)\n\nYou are now ready to start sending messages from your device! Each device may be provisioned to stream the datagrams to the backend service of your choice in a variety of standard and custom formats.\n"},"gettingstarted/troubleshooting-guide.html":{"url":"gettingstarted/troubleshooting-guide.html","title":"Troubleshooting Guide","keywords":"","body":"Troubleshooting Guide\nHow to ask for help\nAlways provide these details when asking for help. This helps us understand your setup and save time.\n\nRun os.uname() on your module to get the version numbers\nYour module's type & version (e.g. FiPy 1.0)\nAny shields, or devices connected (e.g. Pytrack, Extension Board 3.0 with “x\" sensor)\nYour Operating System's version\nPymakr version\nAtom / VSCode version\nHave you looked at our documentation and similar issues on the forum?\n\nFirmware Update\nFirmware file has unexpected sha1 checksum.\nIf you're trying to update to the latest development firmware, make sure you use the development release of the Firmware Updater.\nMy module is recognised as the wrong type\nOpen a support ticket with the details and send us the result of this code:\nimport machine, binascii \nbinascii.hexlify(machine.unique_id())\n\nConnecting to the module\nModule stuck in bootloader mode\nNormally, the firmware updater switches back to application mode at the end of an upgrade. If that doesn't happen for some reason, re-plugging the USB cable also puts the device back into application mode.\nPymakr\nMake sure you have the latest version of Pymakr and Atom/VSCode installed.\nSynchronising a project results in ‘Failed to allocate memory' error\nSynchronising takes a bit of memory, so this error can occur when code running on the board already is taking a substantial amount of memory.\nSolution: use safe boot with REPL or Expansion Board when synchronising\nAtom\nFailed to load package: Cannot find module ‘serialport'\nIn some cases, this is caused by the Atom Package Manager (apm) using Python 3.x, while node-gyp (used for compiling the serialport lib) needs Python 2.x. To confirm this, apm —version can be run to check which Python version apm is using.\nSolution: Tell the package manager to use python 2 instead. Running the following command switches apm to 2.7:\necho “python=/usr/bin/python2.7” >> ~/.atom/.apmrc\n\nNow reinstall Pymakr or run apm install from the Pymakr package located in ~/.atom/packages/pymakr\nCould not locate the bindings file\nIf the installation of the serialport library failed, it reverts back to the precompiled version that is included in the plugin. This is compiled for the latest versions of Atom and loses compatibility with older versions.\nSolution: upgrade to the latest Atom (1.19.0 or higher) or install the previous version of the plugin (apm install pymakr@1.0.3)\nAny error where the traceback contains .atom\\packages\\Pymakr\\ with a capital “P”\nThis happened after Pymakr renamed to pymakr (lowercase) starting at version 1.2.5, but Atom remembers the old folder name inside the packages folder.\nSolution:\n\nUninstall Pymakr\nRemove folder: ~/.atom/.apm/Pymkr\nEmpty folder: ~/.config/Atom/Cache\nReinstall pymakr\n\nCannot connect to Pycom board via REPL\nIn the case of a board that has already has code uploaded to it and is running a loop/non-exiting script, the board may not boot into a REPL.\nSolution: If the board is currently running code, you will need to exit the current script before proceeding: 1. Ensure your board is connected to your computer 2. Press the reset button on the device 3. Press ctrl-c on within the Pymakr console to exit the current script/program\nThe REPL should then appear with the >>> prompt and you will be able to run/sync your code.\nCannot connect to Pycom on Linux\nIf you're a Linux user and can't connect to your board, there might be a permission issue to access the serial port.\nSolution: Run the following command sudo usermod -a -G dialout $USER\nVSCode\nTerminal not opening\nIf the Pymakr terminal is not opening or giving an error, this might be because NodeJS is not installed on your system. This is because the terminal process is running separate from VSCode and depends on your systems NodeJS install.\nSolution: install NodeJS. For Windows 64 machines, install a 32 bit version of NodeJS (for example nvm install 7.8.0 32 when using nvm).\n"},"pymakr/installation/":{"url":"pymakr/installation/","title":"Installation","keywords":"","body":"Installation\n\nPymakr Plugins \nTo make it as easy as possible Pycom has developed a plugin for two popular text editors, called Pymakr. These plugins have been built and are available for the following platforms:\n"},"pymakr/installation/atom.html":{"url":"pymakr/installation/atom.html","title":"Atom","keywords":"","body":"Atom\nFor beginners, users getting started with MicroPython & Pycom as well as Atom text editor users, we recommend the Pymakr Plugin for Atom. This section will help you get started using the Atom Text Editor & Pymakr Plugin.\nPlease follow these steps to install the Pymakr Plugin:\n\nEnsure that you have Atom installed and open.\n\n\n\nNavigate to the Install page, via Atom > Preferences > Install\n\n\n\nSearch for Pymakr and select the official Pycom Pymakr Plugin.\n\n\n\nYou should now see and click the Install button. This will download and install the Pymakr Plugin.\n\n\n\nThat's it! You've installed the Pymakr Plugin for Atom.\n\n\nConnecting via Serial USB\nAfter installing the Pymakr Plugin, you need to take a few seconds to configure it for first time use. Please follow these steps:\n\nConnect your Pycom device to your computer via USB. If you are using an Expansion Board 2.0, and have just finished a firmware upgrade, be sure to remove the wire between GND and G23 and reset your device by pressing the button.\nNote: you don't need the wire for Expansion Board 3.0\n\nOpen Atom and ensure that the Pymakr Plugin has correctly installed.\n\n\n\n\nOpen the Pymakr console by clicking the ^ button, located in the lower right side of the Atom window.\n\n\n\nClick, More followed by Get Serial Ports. This will copy the serial address of your expansion board to your clipboard.\n\n\n\nNavigate to Settings > Global Settings\n\n\n\nPaste the serial address you copied earlier into the text field Device Address\n\n\n\nPress connect and the Pymakr console should show three arrows >>>, indicating that you are connected\n\n\nThese settings can also be applied on a per project basis by clicking Settings then Project Settings. This will open a JSON file which you can edit to enter your desired settings.\nThis process is easiest with either a Pycom Expansion Board or a Pytrack/Pysense as the addresses are automatically selected. For external products such as FTDI USB Serial Cables, the serial address may need to be copied manually. Additionally, the reset button on the device may also need to be pressed before a connection message appears.\n\nConnecting via Telnet\nAfter installing the Pymakr Plugin, a device may be connected via the telnet interface. Please see the following steps:\n\nEnsure that Pycom device is turned on\nConnect the host computer to the WiFi Access Point named after your board (the SSID will be as follows e.g. lopy-wlan-xxxx, wipy-wlan-xxxx, etc.). The password is www.pycom.io.\nFollow the steps as above in the \"Connecting via Serial USB\" section but\nenter 192.168.4.1 as the address.\n\nThe default username and password are micro and python, respectively.\n\nClick Connect in the Pymakr pane, Pymakr will now connect via telnet.\n\n\n"},"pymakr/installation/vscode.html":{"url":"pymakr/installation/vscode.html","title":"Visual Studio Code","keywords":"","body":"Visual Studio Code\nPycom also supports Microsoft's Visual Studio Code IDE platform with the Pymakr Plugin. To download Visual Studio Code, navigate to VS Code.\nYou will also need NodeJS installed on your PC. Please download the latest LTS version available from the NodeJS website.\nPlease follow these steps to install the Pymakr VSCode Extension:\n\nEnsure that you have VSCode installed and open.\n\n\n\nNavigate to the Extensions page, using the 5th button in the left navigation\n\n\n\nSearch for Pymakr and click the install button next to it.\n\n\n\nWithin a few minutes, a reload button should appear. Press it to reload VSCode.\n\n\n\nThat's it! You've installed the Pymakr Extension for VSCode\n\n\nConnecting via Serial USB\nAfter installing the Pymakr Plugin, you need to take a few seconds to configure it for first time use. Please follow these steps:\n\nConnect your Pycom device to your computer via USB. If you are using an\nExpansion Board, and have just finished a firmware upgrade, be sure to Remove\nthe wire between GND and G23 and reset your device by pressing the button.\n\nOpen Visual Studio Code and ensure that the Pymakr Plugin has correctly installed.\n\n\n\n\nClick All commands on the bottom of the Visual Studio Code window\n\n\n\nIn the list that appears, click Pymakr > Extra > List Serial Ports\n\n\n\nThis will list the available serial ports. If Pymakr is able to auto-detect which to use, this will be copied to your clipboard. If not please manually copy the correct serial port.\n\n\n\nOnce again click All commands, then click Pymakr > Global Settings. This will open a JSON file. Paste the serial address you copied earlier into the field address and save the file.\n\n\n\nFinally close the JSON file, click All commands, then Pymakr > Connect to connect your device. The Pymakr console should show three arrows >>>, indicating that you are connected\n\n\nThese settings can also be applied on a per project basis by clicking All commands then Pymakr > Project Settings. This will open a JSON file which you can edit to enter your desired settings for the currently open project.\nThis process is easiest with either a Pycom Expansion Board or a Pytrack/Pysense as the addresses are automatically selected. For external products such as FTDI USB Serial Cables, the serial address may need to be copied manually. Additionally, the reset button on the device may also need to be pressed before a connection message appears.\n\nConnecting via Telnet\nAfter installing the Pymakr Plugin, a device may be connected via the telnet interface. Please see the following steps:\n\nEnsure that Pycom device is turned on\nConnect the host computer to the WiFi Access Point named after your board\n(the SSID will be as follows e.g. lopy-wlan-xxxx, wipy-wlan-xxxx, etc.).\nThe password is www.pycom.io.\n\nFollow the steps as above in the \"Connecting via Serial USB\" section but\nenter 192.168.4.1 as the address.\n\nThe default username and password are micro and python,\nrespectively.\n\nFinally close the JSON file, click All commands, then Pymakr > Connect,\nPymakr will now connect via telnet.\n\n\n"},"pymakr/toolsfeatures.html":{"url":"pymakr/toolsfeatures.html","title":"Tools/Features","keywords":"","body":"Tools/Features\nConsole (REPL)\nMicroPython has an interactive code tool known as the REPL (Read Evaluate Print Line). The REPL allows you to run code on your device, line by line. To begin coding, go to the Pymakr Plugin Console and start typing your code. Start by making the LED change colour.\nimport pycom # we need this module to control the LED\n\npycom.heartbeat(False) # disable the blue blinking\npycom.rgbled(0x00ff00) # make the LED light up green in colour\n\nYou can change the colour by adjusting the hex RGB value.\npycom.rgbled(0xff0000) # now make the LED light up red in colour\n\nThe console can be used to run any python code, also functions or loops.\nUse print() to output contents of variables to the console for you to read. Returned values from functions will also be displayed if they are not caught in a variable. This will not happen for code running from the main or boot files. Here you need to use print() to output to the console.\nNote that after writing or pasting any indented code like a function or a while loop, the user will have to press enter up to three times to tell MicroPython the code is to be closed (this is standard MicroPython & Python behaviour).\nAlso be aware that code written into the REPL is not saved after the device is powered off/on again.\n\nRun\nTo test code on a device, create a new .py file or open an existing one, type the desired code, save the file and then press the Run button. This will run the code directly onto the Pycom board and output the results of the script to the REPL.\nChanges made to files won't be automatically uploaded to the board upon restarting or exiting the Run feature, as the Pycom board will not store this code. In order to push the code permanently to a device, use the Upload feature.\n\nProjects\nPymakr Plugin supports user projects, allowing for pre-configured settings such as default serial address/credentials, files to be ignored and folders to sync.\npymakr.conf\nPymakr Plugin supports local project settings using a file called pymakr.conf. This can be used to store the default serial address of a device, which files to ignore and other settings. An example pymakr.conf is shown below:\n{\n \"address\": \"/dev/cu.usbserial-AB001234\",\n \"username\": \"micro\",\n \"password\": \"python\",\n \"sync_folder\": \"scripts\"\n}\n\nUpload\nThe Pymakr Plugins have a feature to sync and upload code to a device. This can be used for both uploading code to a device as well as testing out scripts by running them live on the device. The following steps demonstrate how to use this feature.\nTo start using the Upload feature, ensure that a project folder has been created for the device. For example, if using the pymakr.conf from above, this project folder should be named scripts. This folder should have the following structure:\n\nLibrary files should be placed into the lib folder, certificates into the cert folder and so on. The Upload button will take the highest level folder (currently open) and upload this to the connected Pycom device. The files will be pushed to the device in exactly the same structure as within the code editor's file directory.\nMore\nClicking the More button within the Pymakr Plugin allows for some additional features. See the options below for specific functionality.\nGet Firmware Version\nRetrieves the firmware version of the Pycom device connected to the Pymakr Plugin instance.\nGet WiFi AP SSID\nRetrieves the default WiFi Access Point SSID of the Pycom device connected to the Pymakr Plugin instance.\nGet Serial Ports\nRetrieves the various serial ports that are available to the Pymakr Plugin instance.\n"},"pymakr/settings.html":{"url":"pymakr/settings.html","title":"Settings","keywords":"","body":"Settings\nBelow you will find a description of the various settings available for Pymakr.\naddress\nThis is the address of the Pycom module you want Pymakr can connect to. This can be either a serial port (e.g COM1 on windows or /dev/cu.usbserial-DQ0054ES on Linux/macOS) or an IP address (Telnet) (e.g. 192.168.4.1 if connected to the AP created by the Pycom module).\nusername\nIf a IP address was provided for the address therefore Pymakr is connecting via Telnet, you will also need to provide a username, the default is micro.\npassword\nIf an IP address was provided for the address, Pymakr is connecting via Telnet. You will also need to provide a password, the default is python.\nsync_folder\nIf left blank, all directories inside the project will be synced to the device when the user clicks upload. If directories are specified, only these directories will be synced, all others will be ignored\nopen_on_start\nIf set to true, the Pymakr console will open and try to connect when the editor is started, or a project is opened.\nsafe_boot_on_upload\nIf set to true, Pymakr will reboot the connected device into safe-mode before uploading. This is useful if your code uses a lot of RAM causing issues with the upload procedure.\nThis feature is only available on modules running firmware version 1.17.0.b1 or higher.\nsync_file_types\nOnly files ending with the extensions listed in this setting will be synced to the device when performing an upload. All other files are ignored. By default this is set to include: py, txt, log, json, xml\nctrl_c_on_connect\nIf set to true, Pymakr will sent the ctrl-c signal to the connected module before uploading. This should stop the script currently running on the device and improve the reliability of the upload process.\n"},"pytrackpysense/introduction.html":{"url":"pytrackpysense/introduction.html","title":"Introduction","keywords":"","body":"Introduction\nIn addition to the Expansion Board, Pycom also offers three additional sensor boards, which are ideal for quickly building a fully functioning IoT solution! Whether the application is environment sensing or asset tracking, these additional boards support a variety of sensors.\nPytrack\nPytrack is a location enabled version of the Expansion Board, intended for use in GPS applications such as asset tracking or monitoring.\n\nFeatures & Hardware\nThe Pytrack is has a number of features including GPS, 3-Axis Accelerometer and Battery Charger. See the list below for detailed specifics about each sensor, including datasheets.\n\nSerial USB\n3-Axis Accelerometer (LIS2HH12)\nBattery Charger (BQ24040 with JST connector)\nGPS and GLONASS (L76-L)\nMicroSD Card Reader\n\nAll of the included sensors are connected to the Pycom device via the I2C interface. These pins are located at P22 (SDA) and P21 (SCL).\nYou can find the datasheet and more info here:\nPysense\nPysense is a sensor packed version of the Expansion Board, intended for use in environment sensing applications such as temperature, humidity monitoring, and light sensing.\n\nFeatures & Hardware\nThe Pysense is packed with a number of sensors and hardware, see the list below for detailed specifics about each sensor, including datasheets.\n\nSerial USB\n3-Axis Accelerometer (LIS2HH12)\nBattery Charger (BQ24040 with JST connector)\nDigital Ambient Light Sensor (LTR-329ALS-01)\nHumidity and Temperature Sensor (SI7006-A20)\nBarometric Pressure Sensor with Altimeter (MPL3115A2)\nMicroSD Card Reader\n\nAll of the included sensors are connected to the Pycom device via the I2C interface. These pins are located at GPI09 (SDA) and GPI08 (SCL).\nYou can find the datasheet and more info here:\nPyscan\nPyscan is a RFID-NFC enabled version of the Expansion Board, intended for use in scanning applications, such as RFID/NFC readers.\n\nFeatures & Hardware\nThe Pyscan is packed with a number of sensors and hardware, see the list below for detailed specifics about each sensor, including datasheets.\n\n3-Axis Accelerometer (LIS2HH12)\nDigital Ambient Light Sensor (LTR-329ALS-01)\nRFID-NFC Chip (MFRC63002HN)\nSerial USB\nBattery Charger (BQ24040 with JST connector)\nMicroSD Card Reader\nUltra low power operation (~1uA in deep sleep)\n\nAll of the included sensors are connected to the Pycom device via the I2C interface. These pins are located at P22 (SDA) and P21 (SCL).\nYou can find the datasheet and more info here:\n"},"pytrackpysense/installation/":{"url":"pytrackpysense/installation/","title":"Installing Software","keywords":"","body":"Installing Software\nAs the development for these devices are on going with additional features being added, every week, it is essential to ensure you frequently check for updates on the Pytrack/Pysense/Pyscan. As well as updating the device firmware, it is important to check the GitHub repository for the respective library files as they as also being updated, to include additional features/functionality.\n"},"pytrackpysense/installation/firmware.html":{"url":"pytrackpysense/installation/firmware.html","title":"Updating Firmware","keywords":"","body":"Updating Firmware\nTo update the firmware on the Pysense/Pytrack/Pyscan/Expansion Board v3, please see the following instructions. The firmware of Pysense/Pytrack/Pyscan/Expansion Board v3 can be updated via the USB port using the terminal tool, DFU-util.\nThe latest firmware DFU file can be downloaded from the links below:\n\nPytrack DFU\nPysense DFU\nExpansion Board DFU\n\nWhile in the normal, application mode, the Pysense/Pytrack/Pyscan/Expansion Board v3 require a Serial USB CDC driver, in DFU, bootloader mode, the DFU driver is required. Below, the USB Product ID is depicted for each case.\n\n\n\nBoard\nDFU bootloader (update mode)\nApplication firmware (normal mode)\n\n\n\n\nPytrack\n0xF014\n0xF013\n\n\nPysense\n0xF011\n0xF012\n\n\nPyscan\n0xEF37\n0xEF38\n\n\nExpansion Board v3\n0xEF99\n0xEF98\n\n\n\nNote: USB Vendor ID is always 0x04D8.\nInstalling the DFU-util Tools\nmacOS\nIf using homebrew:\n$ brew install dfu-util\n\nIf using MacPorts:\nport install libusb dfu-util\n\nLinux\nUbuntu or Debian:\n$ sudo apt-get install dfu-util\n\nFedora:\n$ sudo yum install dfu-util\n\nArch:\n$ sudo pacman -Sy dfu-util\n\nWindows\n\nDFU-util v0.9 – Tool to upload the firmware to the Pytrack/Pysense\nZadig – Installer tool for the Pytrack/Pysense board DFU Firmware\n\nTo uploaded the latest DFU firmware to the Pytrack/Pysense, first install the DFU drivers to the host computer. Open Zadig and select libusbK as the driver.\nTo install the drivers, the Pytrack/Pysense board must be in DFU-mode:\n\nDisconnect the USB cable\nHold down the button on the shield\nConnect the USB cable\nKeep the button pressed for at least one second\nRelease the button. When the board is connected in DFU-mode, it will be in this state for 7 seconds.\nClick the“Install Driver button immediately. If the driver was unsuccessful, repeat from step 1.\nHere the USB ID has to be the DFU-bootloader one (0xF014for Pytrack or 0xF011 for Pysense).\nThis is a successful DFU driver installation for Pytrack:\n\n\n\n\nOpen the command prompt and navigate to the directory where the DFU-util and the firmware was downloaded (must be in same directory). Repeat the procedure to get the board in DFU-mode and run the command below but replace X.X.X with the firmware version and replace Pysense with Pytrack if it is the Pytrack that is to be updated (e.g: pytrack_0.0.8.dfu):\ndfu-util-static.exe -D pysense_X.X.X.dfu\n\nIf the update was successful, a message,\"Done!\" should appear in the bottom of the command prompt.\nDouble-check Serial USB (CDC) driver is installed in Application mode: if, by mistake, the libusbk driver was installed while the USB ID is the Application mode (0xF013 for Pytrack or 0xF012 for Pysense), then the Serial USB (CDC) driver has to be installed for application mode. This will allow Windows to allocate a COM port, which is required for REPL console.\n\nUsing DFU-util with Pytrack, Pysense and Expansion Board v3\nTo enter update mode follow these steps:\n\nUnplug the device\nPress the button and keep it held (on the Expansion Board the S1 button)\nPlug in the USB cable to the host computer and wait 1 second before releasing the button\nAfter this you will have approximately 7 seconds to run the DFU-util tool\n\nmacOS and Linux:\n$ dfu-util -D pytrack_0.0.8.dfu\n\nYou might need to run dfu-util as sudo. In that case, you will need to enter your password.\n\nAn output, similar to the one below, will appear upon successful installation:\ndfu-util 0.9\n\nCopyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.\nCopyright 2010-2016 Tormod Volden and Stefan Schmidt\nThis program is Free Software and has ABSOLUTELY NO WARRANTY\nPlease report bugs to http://sourceforge.net/p/dfu-util/tickets/\n\nMatch vendor ID from file: 04d8\nMatch product ID from file: f014\nOpening DFU capable USB device...\nID 04d8:f014\nRun-time device DFU version 0100\nClaiming USB DFU Runtime Interface...\nDetermining device status: state = dfuIDLE, status = 0\ndfu-util: WARNING: Runtime device already in DFU state ?!?\nClaiming USB DFU Interface...\nSetting Alternate Setting #0 ...\nDetermining device status: state = dfuIDLE, status = 0\ndfuIDLE, continuing\nDFU mode device DFU version 0100\nDevice returned transfer size 64\nCopying data from PC to DFU device\nDownload [=========================] 100% 16384 bytes\nDownload done.\nstate(2) = dfuIDLE, status(0) = No error condition is present\nDone!\n\nDebugging\nUsing lsusb command, the Pytrack/Pysense device should be visible in both normal and bootloader modes.\nFor exemple, a Pytrack board is visible as either:\n\nBus 020 Device 004: ID 04d8:f014 Microchip Technology Inc. Application Specific Device\nthis is bootloader mode (f014 is USB PID), active just for 7-8 seconds, if the reset button was just pressed before plugging USB connector.\n\n\nBus 020 Device 005: ID 04d8:f013 Microchip Technology Inc. Pytrack Serial: Pyabcde0\nthis is normal, application mode (f013 is USB PID), this means the bootloader verified application partition and it boot-up correctly.\n\n\n\n"},"pytrackpysense/installation/drivers.html":{"url":"pytrackpysense/installation/drivers.html","title":"Installing Drivers - Windows 7","keywords":"","body":"Installing Drivers - Windows 7\nPytrack and Pysense will work out of the box for Windows 8/10/+, macOS as well as Linux. If using Windows 7, drivers to support the boards will need to be installed.\nPlease follow the instructions below to install the required drivers.\nDownload\nPlease download the driver software from the link below.\nPytrack/Pysense/Pyscan/Expansion Board 3 Driver\nInstallation\nFirst navigate open the Windows start menu and search/navigate to Device Manager. You should see your Pytrack/Pysense in the dropdown under other devices.\n\nRight click the device and select Update Driver Software.\n\nSelect the option to Browse my computer for driver software.\n\nNext you will need to navigate to where you downloaded the driver to (e.g. Downloads Folder).\n\nSpecify the folder in which the drivers are contained. If you haven't extracted the .zip file, please do this before selecting the folder.\n\nYou may receive a warning, suggesting that windows can't verify the publisher of this driver. Click Install this driver software anyway as this link points to our official driver.\n\nIf the installation was successful, you should now see a window specifying that the driver was correctly installed.\n\nTo confirm that the installation was correct, navigate back to the Device Manager and click the dropdown for other devices. The warning label should now be gone and Pytrack/Pysense should be installed.\n\n"},"pytrackpysense/installation/libraries.html":{"url":"pytrackpysense/installation/libraries.html","title":"Installing Libraries","keywords":"","body":"Installing Libraries\nTo utilise the sensors on the Pytrack and Pysense, Pycom has written libraries to make reading to/from the various sensors accessible via an API. These libraries reside at the Pycom GitHub repository and the latest versions can be found under the releases page.\nGitHub Repository\nDownload the repository as a .zip file, navigate to the correct device (Pysense/Pytrack), extract the files and then upload the desired files to the device in the instructions below.\nUploading the Libraries to a Device\nThese libraries should be uploaded to a device (LoPy, SiPy, WiPy 2.0, etc.) in the same process as a standard MicroPython library. The various .py files should be placed into the /lib folder on the device. For example, if using the Pysense and the user wishes to enable the only Accelerometer and the Light Sensor, they should place the following .py files into the device's /lib folder:\n- pysense.py\n- LIS2HH12.py\n- LTR329ALS01.py\n\nAdd as many or as few of the libraries that are required.\nIn addition to the Pysense or Pytrack specific libraries, you also need to upload the pycoproc.py file from the _lib/pycoproc_ folder inside the libraries archive.\nThe Pytrack and Pysense boards behave the same as the Expansion Board. Upload, Run and upload code to Pycom modules via the Pymakr Plugin, in exactly the same process.\n\nImporting/Using the Libraries\nOnce the libraries are uploaded to the device, they can be used/imported as a typical MicroPython library would be. For example, importing and using the light sensor on the Pysense:\nfrom pysense import Pysense\nfrom LTR329ALS01 import LTR329ALS01\n\npy = Pysense()\nlt = LTR329ALS01(py)\n\nprint(lt.light())\n\n"},"pytrackpysense/apireference/":{"url":"pytrackpysense/apireference/","title":"API Reference","keywords":"","body":"API Reference\nTo simplify usability, APIs for the libraries have been created, abstracting away the low level interactions with the sensors. The next following pages refer to the respective libraries for the Pytrack, Pysense, and Pyscan.\n"},"pytrackpysense/apireference/pytrack.html":{"url":"pytrackpysense/apireference/pytrack.html","title":"Pytrack","keywords":"","body":"Pytrack\nThis chapter describes the various libraries which are designed for the Pytrack board. This includes details about the various methods and classes available for each of the Pytrack's sensors.\n3-Axis Accelerometer (LIS2HH12)\nPytrack has a 3-Axis Accelerometer that provides outputs for acceleration as well as roll, pitch and yaw.\nConstructors\nclass LIS2HH12(pytrack = None, sda = 'P22', scl = 'P21')\nCreates a LIS2HH12 object, that will return values for acceleration, roll, pitch and yaw. Constructor must be passed a Pytrack or I2C object to successfully construct.\nMethods\nLIS2HH12.acceleration()\nRead the acceleration from the LIS2HH12. Returns a tuple with the 3 values of acceleration (G).\nLIS2HH12.roll()\nRead the current roll from the LIS2HH12. Returns a float in degrees in the range -180 to 180.\nLIS2HH12.pitch()\nRead the current pitch from the LIS2HH12. Returns a float in degrees in the range -90 to 90. Once the board tilts beyond this range the values will repeat. This is due to a lack of yaw measurement, making it not possible to know the exact orientation of the board.\nGPS with GLONASS (Quectel L76-L GNSS)\nPytrack has a GPS (with GLONASS) that provides outputs longitude/latitude, speed and other information about the Pytrack's location.\nConstructors\nclass L76GNSS(pytrack = None, sda = 'P22', scl = 'P21', timeout = None)\nCreates a L76GNSS object, that will return values for longitude and latitude. Constructor must be passed a Pytrack or I2C object to successfully construct. Set the timeout to a time period (in seconds) for the GPS to search for a lock. If a lock is not found by the time the timeout has expired, the coordinates method will return (None, None).\nMethods\nL76GNSS.coordinates(debug = False)\nRead the longitude and latitude from the L76GNSS. Returns a tuple with the longitude and latitude. With debug set to True the output from the GPS is verbose.\nPlease note that more functionality is being added weekly to these libraries. If a required feature is not available, feel free to contribute with a pull request at the Libraries GitHub repository\n\n"},"pytrackpysense/apireference/pysense.html":{"url":"pytrackpysense/apireference/pysense.html","title":"Pysense","keywords":"","body":"Pysense\nThis chapter describes the various libraries which are designed for the Pysense board. This includes details about the various methods and classes available for each of the Pysense's sensors.\n3-Axis Accelerometer (LIS2HH12)\nPysense has a 3-Axis Accelerometer that provides outputs for acceleration as well as roll, pitch and yaw.\nConstructors\nclass LIS2HH12(pysense = None, sda = 'P22', scl = 'P21')\nCreates a LIS2HH12 object, that will return values for acceleration, roll, pitch and yaw. Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nLIS2HH12.acceleration()\nRead the acceleration from the LIS2HH12. Returns a tuple with the 3 values of acceleration (G).\nLIS2HH12.roll()\nRead the current roll from the LIS2HH12. Returns a float in degrees in the range -180 to 180.\nLIS2HH12.pitch()\nRead the current pitch from the LIS2HH12. Returns a float in degrees in the range -90 to 90. Once the board tilts beyond this range the values will repeat. This is due to a lack of yaw measurement, making it not possible to know the exact orientation of the board.\nDigital Ambient Light Sensor (LTR-329ALS-01)\nPysense has a dual light sensor that provides outputs for external light levels in lux. See the datasheet for more information about the wavelengths of the two sensors.\nConstructors\nclass LTR329ALS01(pysense = None, sda = 'P22', scl = 'P21', gain = ALS_GAIN_1X, integration = ALS_INT_100, rate = ALS_RATE_500)\nCreates a LTR329ALS01 object, that will return values for light in lux. Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nLTR329ALS01.light()\nRead the light levels of both LTR329ALS01 sensors. Returns a tuple with two values for light levels in lux.\nArguments\nThe following arguments may be passed into the constructor.\n\ngain: ALS_GAIN_1X,ALS_GAIN_2X, ALS_GAIN_4X, ALS_GAIN_8X, ALS_GAIN_48X, ALS_GAIN_96X\nintegration: ALS_INT_50, ALS_INT_100, ALS_INT_150, ALS_INT_200, ALS_INT_250, ALS_INT_300, ALS_INT_350, ALS_INT_400\nrate: ALS_RATE_50, ALS_RATE_100, ALS_RATE_200, ALS_RATE_500, ALS_RATE_1000, ALS_RATE_2000\n\nHumidity and Temperature Sensor (SI7006A20)\nPysense has a Humidity and Temperature sensor that provides values of relative humidity and external temperature.\nConstructors\nclass SI7006A20(pysense = None, sda = 'P22', scl = 'P21')\nCreates a SI7006A20 object, that will return values for humidity (%) and temperature ('C). Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nSI7006A20.humidity()\nRead the relative humidity of the SI7006A20. Returns a float with the percentage relative humidity.\nSI7006A20.temperature()\nRead the external temperature of the SI7006A20. Returns a float with the temperature.\nBarometric Pressure Sensor with Altimeter (MPL3115A2)\nPysense has a Barometric Pressure sensor that provides readings for pressure, altitude as well as an additional temperature sensor.\nConstructors\nclass MPL3115A2(pysense = None, sda = 'P22', scl = 'P21', mode = PRESSURE)\nCreates a MPL3115A2 object, that will return values for pressure (Pa), altitude (m) and temperature ('C). Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nMPL3115A2.pressure()\nRead the atmospheric pressure of the MPL3115A2. Returns a float with the pressure in (Pa).\nMPL3115A2.altitude()\nRead the altitude of the MPL3115A2. Returns a float with the altitude in (m).\nMPL3115A2.temperature()\nRead the temperature of the MPL3115A2. Returns a float with the temperature in ('C).\nArguments\nThe following arguments may be passed into the constructor.\n\nmode: PRESSURE, ALTITUDE\n\nPlease note that more functionality is being added weekly to these libraries. If a required feature is not available, feel free to contribute with a pull request at the Libraries GitHub repository\n\n"},"pytrackpysense/apireference/pyscan.html":{"url":"pytrackpysense/apireference/pyscan.html","title":"Pyscan","keywords":"","body":"Pyscan\nThis chapter describes the various libraries which are designed for the Pyscan board. This includes details about the various methods and classes available for each of the Pyscan's sensors.\n3-Axis Accelerometer (LIS2HH12)\nPysense has a 3-Axis Accelerometer that provides outputs for acceleration as well as roll, pitch and yaw.\nConstructors\nclass LIS2HH12(pysense = None, sda = 'P22', scl = 'P21')\nCreates a LIS2HH12 object, that will return values for acceleration, roll, pitch and yaw. Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nLIS2HH12.acceleration()\nRead the acceleration from the LIS2HH12. Returns a tuple with the 3 values of acceleration (G).\nLIS2HH12.roll()\nRead the current roll from the LIS2HH12. Returns a float in degrees in the range -180 to 180.\nLIS2HH12.pitch()\nRead the current pitch from the LIS2HH12. Returns a float in degrees in the range -90 to 90. Once the board tilts beyond this range the values will repeat. This is due to a lack of yaw measurement, making it not possible to know the exact orientation of the board.\nDigital Ambient Light Sensor (LTR-329ALS-01)\nPysense has a dual light sensor that provides outputs for external light levels in lux. See the datasheet for more information about the wavelengths of the two sensors.\nConstructors\nclass LTR329ALS01(pysense = None, sda = 'P22', scl = 'P21', gain = ALS_GAIN_1X, integration = ALS_INT_100, rate = ALS_RATE_500)\nCreates a LTR329ALS01 object, that will return values for light in lux. Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nLTR329ALS01.light()\nRead the light levels of both LTR329ALS01 sensors. Returns a tuple with two values for light levels in lux.\nArguments\nThe following arguments may be passed into the constructor.\n\ngain: ALS_GAIN_1X,ALS_GAIN_2X, ALS_GAIN_4X, ALS_GAIN_8X, ALS_GAIN_48X, ALS_GAIN_96X\nintegration: ALS_INT_50, ALS_INT_100, ALS_INT_150, ALS_INT_200, ALS_INT_250, ALS_INT_300, ALS_INT_350, ALS_INT_400\nrate: ALS_RATE_50, ALS_RATE_100, ALS_RATE_200, ALS_RATE_500, ALS_RATE_1000, ALS_RATE_2000\n\nPyscan NFC library (MFRC6300)\nConstructors\nclass MFRC630(pyscan=None, sda='P22', scl='P21', timeout=None, debug=False)\nCreates a MFRC630 object. Constructor must be passed a Pyscan or I2C object to successfully construct.\nMethods\nMFRC630.mfrc630_cmd_init()\nInitialise the MFRC630 with some settings\nMFRC630.mfrc630_cmd_reset()\nReset the device. Stops the currently active command and resets device.\nMFRC630.mfrc630_cmd_idle()\nSet the device into idle mode. Stops the currently active command and return to idle mode.\nMFRC630.mfrc630_cmd_load_key(key)\nLoads the provided key into the key buffer.\n\nkey Array which holds the MIFARE key, it is always 6 bytes long\n\nMFRC630.mfrc630_MF_read_block(block_address, dest)\nReads a block of memory from an authenticated card. Try to read a block of memory from the card with the appropriate timeouts and error checking.\n\nblock_address The block to read\ndest The array in which to write the 16 bytes read from the card\n\nReturns 0 for failure, otherwise the number of bytes received.\nMFRC630.mfrc630_MF_auth(uid, key_type, block)\nPerform a MIFARE authentication procedure. This function is a higher-level wrapper around the MF authenticate command. The result of the authentication is checked to identify whether it appears to have succeeded. The key must be loaded into the key buffer with MFRC630.mfrc630_cmd_load_key(key).\nOnce authenticated, the authentication MUST be stopped manually by calling the mfrc630_MF_deauth() function or otherwise disabling the Crypto1 ON bit in the status register.\n\nkey_type The MIFARE key A or B (MFRC630_MF_AUTH_KEY_A or MFRC630_MF_AUTH_KEY_B) to use\nblock The block to authenticate\nuid The authentication procedure required the first four bytes of the card's UID to authenticate\n\nReturns 0 in case of failure, nonzero in case of success.\nMFRC630.mfrc630_MF_deauth()\nDisables MIFARE authentication. Disable the Crypto1 bit from the status register to disable encryption.\nMFRC630.mfrc630_iso14443a_WUPA_REQA(instruction)\nSend WUPA and REQA. Returns the response byte, the answer to request A byte (ATQA), or 0 in case of no answer.\n\ninstruction: MFRC630_ISO14443_CMD_WUPA, MFRC630_ISO14443_CMD_REQA\n\nMFRC630.mfrc630_iso14443a_select(uid)\nPerforms the SELECT procedure to discover a card's UID. This performs the SELECT procedure as explained in ISO14443A, this determines the UID of the card, if multiple cards are present, a collision will occur, which is handled according to the norm.\n\nuid: The UID of the card will be stored into this array.\n\nReturns the length of the UID in bytes (4, 7, 10), or 0 in case of failure.\nMFRC630.print_debug(msg)\nPrints debug statements if DEBUG is enabled.\nMFRC630.format_block(block, length)\nPrints block with length.\nMFRC630.mfrc630_format_block(data, len)\nConverts data to hexadecimal format.\n\ndata The array to be formatted\nlen The number of bytes to format\n\nMFRC630.mfrc630_print_block(data, len)\nPrints the bytes in data array in hexadecimal format, separated by spaces using the mfrc630_format_block method.\n\ndata The array to be printed\nlen The number of bytes to print\n\nPlease note that more functionality is being added weekly to these libraries. If a required feature is not available, feel free to contribute with a pull request at the Libraries GitHub repository\n\n"},"pytrackpysense/apireference/sleep.html":{"url":"pytrackpysense/apireference/sleep.html","title":"Sleep","keywords":"","body":"Sleep\nThis chapter describes the various methods for sleep and wakeup which are embedded in Pytrack and Pysense libraries. Both Pytrack and Pysense have the same methods, although the appropriate class, either pytrack or pysense, has to be instantiated.\nQuick Usage Example\nThe following example is also available at Sleep Wakeup Example Libraries GitHub repository\n#from pytrack import Pytrack\nfrom pysense import Pysense\nfrom LIS2HH12 import LIS2HH12\nimport time\n\n#py = Pytrack()\npy = Pysense()\n\n# display the reset reason code and the sleep remaining in seconds\n# possible values of wakeup reason are:\n# WAKE_REASON_ACCELEROMETER = 1\n# WAKE_REASON_PUSH_BUTTON = 2\n# WAKE_REASON_TIMER = 4\n# WAKE_REASON_INT_PIN = 8\n\nprint(\"Wakeup reason: \" + str(py.get_wake_reason()))\nprint(\"Approximate sleep remaining: \" + str(py.get_sleep_remaining()) + \" sec\")\ntime.sleep(0.5)\n\n# enable wakeup source from INT pin\npy.setup_int_pin_wake_up(False)\n\nacc = LIS2HH12()\n\n# enable activity and also inactivity interrupts, using the default callback handler\npy.setup_int_wake_up(True, True)\n\n# set the acceleration threshold to 2000mG (2G) and the min duration to 200ms\nacc.enable_activity_interrupt(2000, 200)\n\n# go to sleep for 5 minutes maximum if no accelerometer interrupt happens\npy.setup_sleep(300)\npy.go_to_sleep()\n\nMethods\npytrack.get_sleep_remaining()\nIn the event of a sleep session that was awoken by an asynchronous event (Accelerometer, INT pin or Reset button) the approximate sleep remaining interval (expressed in seconds) can be found out. The user has to manually use setup_sleep() to configure the next sleep interval.\npytrack.get_wake_reason()\nReturns the last wakeup reason. Possible values are:\n# WAKE_REASON_ACCELEROMETER = 1 # Accelerometer activity/inactivity detection\n# WAKE_REASON_PUSH_BUTTON = 2 # Pytrack/Pysense reset buttom\n# WAKE_REASON_TIMER = 4 # Normal timeout of the sleep interval\n# WAKE_REASON_INT_PIN = 8 # INT pin\n\nNote: the WAKE_REASON_INT_PIN can be used if the PIC_RC1 pin (pin#6 on External IO Header) is toggled.\nAs in the above example, this method should be called at the beginning of the script, to find out the reset (wakeup) reason.\npytrack.go_to_sleep([gps=True])\nPuts the board in sleep mode, for the duration, which has to be set previously with pytrack.setup_sleep(timout_sec). The optional boolean parameter sets the GPS state during sleep.\nMicroPython code, which is after this function, is not executed, as wakeup will restart MicroPython.\npytrack.setup_int_wake_up(rising, falling])\nEnables as wakeup source, the accelerometer INT pin (PIC - RA5). The boolean parameters will indicate rising edge (activity detection) and/or falling edge (inactivity detection) is configured.\nThe accelerometer (class LIS2HH12) has to be also configured for a certain acceleration threshold and duration. Code snippet:\nfrom pytrack import Pytrack\nfrom LIS2HH12 import LIS2HH12\n\npy = Pytrack()\nacc = LIS2HH12()\n\n# enable activity and also inactivity interrupts, using the default callback handler\npy.setup_int_wake_up(True, True)\n\n# set the acceleration threshold to 2000mG (2G) and the min duration to 200ms\nacc.enable_activity_interrupt(2000, 200)\n\npytrack.setup_int_pin_wake_up([rising_edge = True])\nEnables as wakeup source, the INT pic (PIC - RC1, pin#6 on External IO Header). Either rising or falling edge has to be set, by default it's rising edge.\npytrack.setup_sleep(time_seconds)\nSets the sleep interval, specified in seconds. The actual sleep will be started by calling go_to_sleep() method.\nPlease note that more functionality is being added weekly to these libraries. If a required feature is not available, feel free to contribute with a pull request at the Libraries GitHub repository\n\n"},"tutorials/introduction.html":{"url":"tutorials/introduction.html","title":"Introduction","keywords":"","body":"Introduction\n\nTutorials and Examples\nThis section contains tutorials and examples for use with Pycom modules and Expansion boards.\nGeneral Pycom tutorials contains tutorials that may be run on any Pycom device, such as connecting to a WiFi network, Bluetooth, controlling I/O pins etc. Later sections are specific to the LoPy and SiPy devices such as setting up a LoRa node or connecting to the Sigfox network. The final sections are related to examples using the Pytrack and Pysense.\nBefore starting, ensure that any Pycom devices are running the latest firmware; for instructions see Firmware Updates.\nThe source code for these tutorials, along with the required libraries can be found in in the pycom-libraries repository.\n"},"tutorials/all/":{"url":"tutorials/all/","title":"All Pycom Device Examples","keywords":"","body":"All Pycom Device Examples\nThis section contains generic examples that will work across all Pycom devices and Expansion Boards.\n"},"tutorials/all/repl.html":{"url":"tutorials/all/repl.html","title":"REPL","keywords":"","body":"REPL\nUsing the Pymakr Plugin, open and connect a device or use serial terminal (PuTTY, screen, picocom, etc). Upon connecting, there should be a blank screen with a flashing cursor. Press Enter and a MicroPython prompt should appear, i.e. >>>. Let's make sure it is working with the obligatory test:\n>>> print(\"Hello LoPy!\")\nHello LoPy!\n\nIn the example above, the >>> characters should not be typed. They are there to indicate that the text should be placed after the prompt. Once the text has been entered print(\"Hello LoPy!\") and pressed Enter, the output should appear on screen, identical to the example above.\nBasic Python commands can be tested out in a similar fashion.\nIf this is not working, try either a hard reset or a soft reset; see below.\nHere are some other example, utilising the device's hardware features:\n>>> from machine import Pin\n>>> led = Pin('G16', mode=Pin.OUT, value=1)\n>>> led(0)\n>>> led(1)\n>>> led.toggle()\n>>> 1 + 2\n3\n>>> 5 / 2\n2.5\n>>> 20 * 'py'\n'pypypypypypypypypypypypypypypypypypypypy'\n\nResetting the Device\nIf something goes wrong, the device can be reset with two methods. The first is to press CTRL-D at the MicroPython prompt, which will perform a soft reset. A message, as following, will appear:\n>>>\nPYB: soft reboot\nMicroPython v1.4.6-146-g1d8b5e5 on 2016-10-21; LoPy with ESP32\nType \"help()\" for more information.\n>>>\n\nIf that still isn't working a hard reset can be performed (power-off/on) by pressing the RST switch (the small black button next to the RGB LED). Using telnet, this will end the session, disconnecting the program that was used to connect to the Pycom Device.\n"},"tutorials/all/wlan.html":{"url":"tutorials/all/wlan.html","title":"WLAN","keywords":"","body":"WLAN\nThe WLAN is a system feature of all Pycom devices, therefore it is enabled by default.\nIn order to retrieve the current WLAN instance, run:\n>>> from network import WLAN\n>>> wlan = WLAN() # we call the constructor without params\n\nThe current mode (WLAN.AP after power up) may be checked by running:\n>>> wlan.mode()\n\nWhen changing the WLAN mode, if following the instructions below, the WLAN connection to the Pycom device will be broken. This means commands will not run interactively over WiFi.\nThere are two ways around this:\n\nPut this setup code into the boot.py file of the Pycom device so that it gets executed automatically after reset.\nDuplicate the REPL on UART. This way commands can be run via Serial USB.\n\n\nConnecting to a Router\nThe WLAN network class always boots in WLAN.AP mode; to connect it to an existing network, the WiFi class must be configured as a station:\nfrom network import WLAN\nwlan = WLAN(mode=WLAN.STA)\n\nNow the device may proceed to scan for networks:\nnets = wlan.scan()\nfor net in nets:\n if net.ssid == 'mywifi':\n print('Network found!')\n wlan.connect(net.ssid, auth=(net.sec, 'mywifikey'), timeout=5000)\n while not wlan.isconnected():\n machine.idle() # save power while waiting\n print('WLAN connection succeeded!')\n break\n\nAssigning a Static IP Address at Boot Up\nIf the users wants their device to connect to a home router upon boot up, using with a fixed IP address, use the following script as /flash/boot.py:\nimport machine\nfrom network import WLAN\nwlan = WLAN() # get current object, without changing the mode\n\nif machine.reset_cause() != machine.SOFT_RESET:\n wlan.init(mode=WLAN.STA)\n # configuration below MUST match your home router settings!!\n wlan.ifconfig(config=('192.168.178.107', '255.255.255.0', '192.168.178.1', '8.8.8.8'))\n\nif not wlan.isconnected():\n # change the line below to match your network ssid, security and password\n wlan.connect('mywifi', auth=(WLAN.WPA2, 'mywifikey'), timeout=5000)\n while not wlan.isconnected():\n machine.idle() # save power while waiting\n\nNotice how we check for the reset cause and the connection status, this is crucial in order to be able to soft reset the LoPy during a telnet session without breaking the connection.\n\nMultiple Networks using a Static IP Address\nThe following script holds a list with nets and an optional list of wlan_config to set a fixed IP\nimport os\nimport machine\n\nuart = machine.UART(0, 115200)\nos.dupterm(uart)\n\nknown_nets = {\n '': {'pwd': ''},\n '': {'pwd': '', 'wlan_config': ('10.0.0.114', '255.255.0.0', '10.0.0.1', '10.0.0.1')}, # (ip, subnet_mask, gateway, DNS_server)\n}\n\nif machine.reset_cause() != machine.SOFT_RESET:\n from network import WLAN\n wl = WLAN()\n wl.mode(WLAN.STA)\n original_ssid = wl.ssid()\n original_auth = wl.auth()\n\n print(\"Scanning for known wifi nets\")\n available_nets = wl.scan()\n nets = frozenset([e.ssid for e in available_nets])\n\n known_nets_names = frozenset([key for key in known_nets])\n net_to_use = list(nets & known_nets_names)\n try:\n net_to_use = net_to_use[0]\n net_properties = known_nets[net_to_use]\n pwd = net_properties['pwd']\n sec = [e.sec for e in available_nets if e.ssid == net_to_use][0]\n if 'wlan_config' in net_properties:\n wl.ifconfig(config=net_properties['wlan_config'])\n wl.connect(net_to_use, (sec, pwd), timeout=10000)\n while not wl.isconnected():\n machine.idle() # save power while waiting\n print(\"Connected to \"+net_to_use+\" with IP address:\" + wl.ifconfig()[0])\n\n except Exception as e:\n print(\"Failed to connect to any known network, going into AP mode\")\n wl.init(mode=WLAN.AP, ssid=original_ssid, auth=original_auth, channel=6, antenna=WLAN.INT_ANT)\n\nConnecting to a WPA2-Enterprise network\nConnecting with EAP-TLS:\nBefore connecting, obtain and copy the public and private keys to the device, e.g. under location /flash/cert. If it is required to validate the server's public key, an appropriate CA certificate (chain) must also be provided.\nfrom network import WLAN\n\nwlan = WLAN(mode=WLAN.STA)\nwlan.connect(ssid='mywifi', auth=(WLAN.WPA2_ENT,), identity='myidentity', ca_certs='/flash/cert/ca.pem', keyfile='/flash/cert/client.key', certfile='/flash/cert/client.crt')\n\nConnecting with EAP-PEAP or EAP-TTLS:\nIn case of EAP-PEAP (or EAP-TTLS), the client key and certificate are not necessary, only a username and password pair. If it is required to validate the server's public key, an appropriate CA certificate (chain) must also be provided.\nfrom network import WLAN\n\nwlan = WLAN(mode=WLAN.STA)\nwlan.connect(ssid='mywifi', auth=(WLAN.WPA2_ENT, 'username', 'password'), identity='myidentity', ca_certs='/flash/cert/ca.pem')\n\n"},"tutorials/all/ble.html":{"url":"tutorials/all/ble.html","title":"Bluetooth","keywords":"","body":"Bluetooth\nAt present, basic BLE functionality is available. More features will be implemented in the near future, such as pairing. This page will be updated in line with these features.\nFull info on bluetooth can be found within Bluetooth page of the Firmware API Reference.\nScan for BLE Devices\nScan for all of the advertising devices within range of the scanning device.\nbluetooth.start_scan(10) # starts scanning and stop after 10 seconds\nbluetooth.start_scan(-1) # starts scanning indefinitely until bluetooth.stop_scan() is called\n\nRaw Data from a BLE Device\nA quick usage example that scans and prints the raw data from advertisements.\nfrom network import Bluetooth\n\nbluetooth = Bluetooth()\nbluetooth.start_scan(-1) # start scanning with no timeout\n\nwhile True:\n print(bluetooth.get_adv())\n\nConnect to a BLE Device\nConnecting to a device that is sending advertisements.\nfrom network import Bluetooth\nimport ubinascii\nbluetooth = Bluetooth()\n\n# scan until we can connect to any BLE device around\nbluetooth.start_scan(-1)\nadv = None\nwhile True:\n adv = bluetooth.get_adv()\n if adv:\n try:\n bluetooth.connect(adv.mac)\n except:\n # start scanning again\n bluetooth.start_scan(-1)\n continue\n break\nprint(\"Connected to device with addr = {}\".format(ubinascii.hexlify(adv.mac)))\n\nConnect to a BLE Device and Retrieve Data\nConnecting to a device named 'Heart Rate' and receiving data from it's services.\nfrom network import Bluetooth\nimport time\nbt = Bluetooth()\nbt.start_scan(-1)\n\nwhile True:\n adv = bt.get_adv()\n if adv and bt.resolve_adv_data(adv.data, Bluetooth.ADV_NAME_CMPL) == 'Heart Rate':\n try:\n conn = bt.connect(adv.mac)\n services = conn.services()\n for service in services:\n time.sleep(0.050)\n if type(service.uuid()) == bytes:\n print('Reading chars from service = {}'.format(service.uuid()))\n else:\n print('Reading chars from service = %x' % service.uuid())\n chars = service.characteristics()\n for char in chars:\n if (char.properties() & Bluetooth.PROP_READ):\n print('char {} value = {}'.format(char.uuid(), char.read()))\n conn.disconnect()\n break\n except:\n pass\n else:\n time.sleep(0.050)\n\nRetrieve the Name & Manufacturer from a BLE Device\nUsing resolve_adv_data() to attempt to retrieve the name and manufacturer data from the advertiser.\nimport ubinascii\nfrom network import Bluetooth\nbluetooth = Bluetooth()\n\nbluetooth.start_scan(20)\nwhile bluetooth.isscanning():\n adv = bluetooth.get_adv()\n if adv:\n # try to get the complete name\n print(bluetooth.resolve_adv_data(adv.data, Bluetooth.ADV_NAME_CMPL))\n\n mfg_data = bluetooth.resolve_adv_data(adv.data, Bluetooth.ADV_MANUFACTURER_DATA)\n\n if mfg_data:\n # try to get the manufacturer data (Apple's iBeacon data is sent here)\n print(ubinascii.hexlify(mfg_data))\n\n"},"tutorials/all/https.html":{"url":"tutorials/all/https.html","title":"HTTPS","keywords":"","body":"HTTPS\nBasic connection using ssl.wrap_socket().\nimport socket\nimport ssl\n\ns = socket.socket()\nss = ssl.wrap_socket(s)\nss.connect(socket.getaddrinfo('www.google.com', 443)[0][-1])\n\nBelow is an example using certificates with the blynk cloud.\nCertificate was downloaded from the blynk examples folder and placed in /flash/cert/ on the device.\nimport socket\nimport ssl\n\ns = socket.socket()\nss = ssl.wrap_socket(s, cert_reqs=ssl.CERT_REQUIRED, ca_certs='/flash/cert/ca.pem')\nss.connect(socket.getaddrinfo('cloud.blynk.cc', 8441)[0][-1])\n\nFor more info, check the ssl module in the API reference.\n"},"tutorials/all/mqtt.html":{"url":"tutorials/all/mqtt.html","title":"MQTT","keywords":"","body":"MQTT\nMQTT is a lightweight messaging protocol that is ideal for sending small packets of data to and from IoT devices via WiFi.\nThe broker used in this example is the IO Adafruit platform, which is free and allows for tinkering with MQTT.\nVisit IO Adafruit and create an account. You'll need to get hold of an API Key as well as your credentials. Visit this guide for more information about MQTT and how to use it with Adafruit's Broker.\nThis example will send a message to a topic on the Adafruit MQTT broker and then also subscribe to the same topic, in order to show how to use the subscribe functionality.\nfrom mqtt import MQTTClient\nfrom network import WLAN\nimport machine\nimport time\n\ndef sub_cb(topic, msg):\n print(msg)\n\nwlan = WLAN(mode=WLAN.STA)\nwlan.connect(\"yourwifinetwork\", auth=(WLAN.WPA2, \"wifipassword\"), timeout=5000)\n\nwhile not wlan.isconnected(): \n machine.idle()\nprint(\"Connected to WiFi\\n\")\n\nclient = MQTTClient(\"device_id\", \"io.adafruit.com\",user=\"your_username\", password=\"your_api_key\", port=1883)\n\nclient.set_callback(sub_cb)\nclient.connect()\nclient.subscribe(topic=\"youraccount/feeds/lights\")\n\nwhile True:\n print(\"Sending ON\")\n client.publish(topic=\"youraccount/feeds/lights\", msg=\"ON\")\n time.sleep(1)\n print(\"Sending OFF\")\n client.publish(topic=\"youraccount/feeds/lights\", msg=\"OFF\")\n client.check_msg()\n\n time.sleep(1)\n\n"},"tutorials/all/aws.html":{"url":"tutorials/all/aws.html","title":"AWS","keywords":"","body":"AWS\nThe AWS IoT platform enables devices to connect to the Amazon cloud and lets applications in the cloud interact with Internet-connected things. Common IoT applications either collect and process telemetry from devices or enable users to control a device remotely. Things report their state by publishing messages, in JSON format, on MQTT topics.\nFor more information see this PDF File.\nGetting Started with AWS IoT\nCreating the message broker (Amazon website):\n\nSign in to the AWS Management Console\nNavigate to the IoT Console by clicking on the AWS IoT link\nIn the left navigation pane, choose Register/Manage\nClick on the create button, give your device a name and press create\nClick on the device that has been created\nOn the Details page, in the left navigation pane, choose Security\nOn the Certificates page, choose Create certificate\nDownload all the certificates, then press the Activate and the Attach a Policy buttons. See image\nClick on the Create New Policy button\nOn the Create Policy page, choose a policy name and the actions to authorise.\nGo to the certificates page, click on the three dots of your certificate and attach the policy to the certificate as shown in the diagram\n\nSetting up the device (Pycom device):\n\nDownload the latest sample code from the Pycom GitHub Repository.\nConnect to the device via FTP and put the root CA certificate, the client certificate (*.pem.crt) and the private key (*.private.pem.key) in the /flash/cert folder.\nUpdate the config file with your WiFi settings, the AWS Host and the certificate paths.\nPut the config.py and the main.py in the device flash\n\nConfiguration (config.py):\nThis file contains the WiFi, certificate paths and application specific settings that need to be updated by the user.\n# WiFi configuration\nWIFI_SSID = 'my_wifi_ssid'\nWIFI_PASS = 'my_wifi_password'\n\n# AWS general configuration\nAWS_PORT = 8883\nAWS_HOST = 'aws_host_url'\nAWS_ROOT_CA = '/flash/cert/aws_root.ca'\nAWS_CLIENT_CERT = '/flash/cert/aws_client.cert'\nAWS_PRIVATE_KEY = '/flash/cert/aws_private.key'\n\n################## Subscribe / Publish client #################\nCLIENT_ID = 'PycomPublishClient'\nTOPIC = 'PublishTopic'\nOFFLINE_QUEUE_SIZE = -1\nDRAINING_FREQ = 2\nCONN_DISCONN_TIMEOUT = 10\nMQTT_OPER_TIMEOUT = 5\nLAST_WILL_TOPIC = 'PublishTopic'\nLAST_WILL_MSG = 'To All: Last will message'\n\n####################### Shadow updater ########################\n#THING_NAME = \"my thing name\"\n#CLIENT_ID = \"ShadowUpdater\"\n#CONN_DISCONN_TIMEOUT = 10\n#MQTT_OPER_TIMEOUT = 5\n\n####################### Delta Listener ########################\n#THING_NAME = \"my thing name\"\n#CLIENT_ID = \"DeltaListener\"\n#CONN_DISCONN_TIMEOUT = 10\n#MQTT_OPER_TIMEOUT = 5\n\n####################### Shadow Echo ########################\n#THING_NAME = \"my thing name\"\n#CLIENT_ID = \"ShadowEcho\"\n#CONN_DISCONN_TIMEOUT = 10\n#MQTT_OPER_TIMEOUT = 5\n\nSubscibe / Publish (main.py)\nTo subscribe to a topic:\n\nGo to the AWS Iot page, click on manage and choose your device\nFrom the left hand side, choose Activity and then click MQTT client.\nChoose the topic name you entered in the configuration file.\nMessages should be published as shown in the diagram\n\n# user specified callback function\ndef customCallback(client, userdata, message):\n print(\"Received a new message: \")\n print(message.payload)\n print(\"from topic: \")\n print(message.topic)\n print(\"--------------\\n\\n\")\n\n# configure the MQTT client\npycomAwsMQTTClient = AWSIoTMQTTClient(config.CLIENT_ID)\npycomAwsMQTTClient.configureEndpoint(config.AWS_HOST, config.AWS_PORT)\npycomAwsMQTTClient.configureCredentials(config.AWS_ROOT_CA, config.AWS_PRIVATE_KEY, config.AWS_CLIENT_CERT)\n\npycomAwsMQTTClient.configureOfflinePublishQueueing(config.OFFLINE_QUEUE_SIZE)\npycomAwsMQTTClient.configureDrainingFrequency(config.DRAINING_FREQ)\npycomAwsMQTTClient.configureConnectDisconnectTimeout(config.CONN_DISCONN_TIMEOUT)\npycomAwsMQTTClient.configureMQTTOperationTimeout(config.MQTT_OPER_TIMEOUT)\npycomAwsMQTTClient.configureLastWill(config.LAST_WILL_TOPIC, config.LAST_WILL_MSG, 1)\n\n#Connect to MQTT Host\nif pycomAwsMQTTClient.connect():\n print('AWS connection succeeded')\n\n# Subscribe to topic\npycomAwsMQTTClient.subscribe(config.TOPIC, 1, customCallback)\ntime.sleep(2)\n\n# Send message to host\nloopCount = 0\nwhile loopCount \nShadow updater (main.py)\n# user specified callback functions\ndef customShadowCallback_Update(payload, responseStatus, token):\n if responseStatus == \"timeout\":\n print(\"Update request \" + token + \" time out!\")\n if responseStatus == \"accepted\":\n payloadDict = json.loads(payload)\n print(\"Update request with token: \" + token + \" accepted!\")\n print(\"property: \" + str(payloadDict[\"state\"][\"desired\"][\"property\"]))\n if responseStatus == \"rejected\":\n print(\"Update request \" + token + \" rejected!\")\n\ndef customShadowCallback_Delete(payload, responseStatus, token):\n if responseStatus == \"timeout\":\n print(\"Delete request \" + token + \" time out!\")\n if responseStatus == \"accepted\":\n print(\"Delete request with token: \" + token + \" accepted!\")\n if responseStatus == \"rejected\":\n print(\"Delete request \" + token + \" rejected!\")\n\n# configure the MQTT client\npycomAwsMQTTShadowClient = AWSIoTMQTTShadowClient(config.CLIENT_ID)\npycomAwsMQTTShadowClient.configureEndpoint(config.AWS_HOST, config.AWS_PORT)\npycomAwsMQTTShadowClient.configureCredentials(config.AWS_ROOT_CA, config.AWS_PRIVATE_KEY, config.AWS_CLIENT_CERT)\n\npycomAwsMQTTShadowClient.configureConnectDisconnectTimeout(config.CONN_DISCONN_TIMEOUT)\npycomAwsMQTTShadowClient.configureMQTTOperationTimeout(config.MQTT_OPER_TIMEOUT)\n\n# Connect to MQTT Host\nif pycomAwsMQTTShadowClient.connect():\n print('AWS connection succeeded')\n\ndeviceShadowHandler = pycomAwsMQTTShadowClient.createShadowHandlerWithName(config.THING_NAME, True)\n\n# Delete shadow JSON doc\ndeviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)\n\n# Update shadow in a loop\nloopCount = 0\nwhile True:\n JSONPayload = '{\"state\":{\"desired\":{\"property\":' + str(loopCount) + '}}}'\n deviceShadowHandler.shadowUpdate(JSONPayload, customShadowCallback_Update, 5)\n loopCount += 1\n time.sleep(5)\n\nDelta Listener (main.py)\n# Custom Shadow callback\ndef customShadowCallback_Delta(payload, responseStatus, token):\n payloadDict = json.loads(payload)\n print(\"property: \" + str(payloadDict[\"state\"][\"property\"]))\n print(\"version: \" + str(payloadDict[\"version\"]))\n\n # configure the MQTT client\npycomAwsMQTTShadowClient = AWSIoTMQTTShadowClient(config.CLIENT_ID)\npycomAwsMQTTShadowClient.configureEndpoint(config.AWS_HOST, config.AWS_PORT)\npycomAwsMQTTShadowClient.configureCredentials(config.AWS_ROOT_CA, config.AWS_PRIVATE_KEY, config.AWS_CLIENT_CERT)\n\npycomAwsMQTTShadowClient.configureConnectDisconnectTimeout(config.CONN_DISCONN_TIMEOUT)\npycomAwsMQTTShadowClient.configureMQTTOperationTimeout(config.MQTT_OPER_TIMEOUT)\n\n# Connect to MQTT Host\nif pycomAwsMQTTShadowClient.connect():\n print('AWS connection succeeded')\n\ndeviceShadowHandler = pycomAwsMQTTShadowClient.createShadowHandlerWithName(config.THING_NAME, True)\n\n# Listen on deltas\ndeviceShadowHandler.shadowRegisterDeltaCallback(customShadowCallback_Delta)\n\n# Loop forever\nwhile True:\n time.sleep(1)\n\n"},"tutorials/all/adc.html":{"url":"tutorials/all/adc.html","title":"ADC","keywords":"","body":"ADC\nThis example is a simple ADC sample. For more information please see ADC.\nfrom machine import ADC\nadc = ADC(0)\nadc_c = adc.channel(pin='P13')\nadc_c()\nadc_c.value()\n\nCalibration\nCurrently the ESP32's ADC is not calibrated from the factory. This means it must be calibrated each time you wish to use it. To do this you must firstly measure the internal voltage reference. The following code will connect the 1.1v reference to P22\nfrom machine import ADC\nadc = ADC()\n\n# Output Vref of P22\nadc.vref_to_pin('P22')\n\nNow that the voltage reference is externally accessible you should measure it with the most accurate voltmeter you have access to. Note down the reading in millivolts, e.g. 1120. To disconnect the 1.1v reference from P22 please reset your module. You can now calibrate the ADC by telling it the true value of the internal reference. You should then check your calibration by connecting the ADC to a known voltage source.\n# Set calibration - see note above\nadc.vref(1100)\n\n# Check calibration by reading a known voltage\nadc_c = adc.channel(pin='P16', attn=ADC.ATTN_11DB)\nprint(adc_c.voltage())\n\n"},"tutorials/all/i2c.html":{"url":"tutorials/all/i2c.html","title":"I2C","keywords":"","body":"I2C\nThe following example receives data from a light sensor using I2C. Sensor used is the BH1750FVI Digital Light Sensor.\nimport time\nfrom machine import I2C\nimport bh1750fvi\n\ni2c = I2C(0, I2C.MASTER, baudrate=100000)\nlight_sensor = bh1750fvi.BH1750FVI(i2c, addr=i2c.scan()[0])\n\nwhile(True):\n data = light_sensor.read()\n print(data)\n time.sleep(1)\n\nDrivers for the BH1750FVI\nPlace this sample code into a file named bh1750fvi.py. This can then be imported as a library.\n# Simple driver for the BH1750FVI digital light sensor\n\nclass BH1750FVI:\n MEASUREMENT_TIME = const(120)\n\n def __init__(self, i2c, addr=0x23, period=150):\n self.i2c = i2c\n self.period = period\n self.addr = addr\n self.time = 0\n self.value = 0\n self.i2c.writeto(addr, bytes([0x10])) # start continuos 1 Lux readings every 120ms\n\n def read(self):\n self.time += self.period\n if self.time >= MEASUREMENT_TIME:\n self.time = 0\n data = self.i2c.readfrom(self.addr, 2)\n self.value = (((data[0] \nLight sensor and LoRa\nThis is the same code, with added LoRa connectivity, sending the lux value from the light sensor to another LoRa enabled device.\nimport socket\nimport time\nimport pycom\nimport struct\nfrom network import LoRa\nfrom machine import I2C\nimport bh1750fvi\n\nLORA_PKG_FORMAT = \"!BH\"\nLORA_CONFIRM_FORMAT = \"!BB\"\n\nDEVICE_ID = 1\n\npycom.heartbeat(False)\n\nlora = LoRa(mode=LoRa.LORA, tx_iq=True, region=LoRa.EU868)\nlora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\nlora_sock.setblocking(False)\n\ni2c = I2C(0, I2C.MASTER, baudrate=100000)\nlight_sensor = bh1750fvi.BH1750FVI(i2c, addr=i2c.scan()[0])\n\nwhile(True):\n msg = struct.pack(LORA_PKG_FORMAT, DEVICE_ID, light_sensor.read())\n lora_sock.send(msg)\n\n pycom.rgbled(0x150000)\n\n wait = 5\n while (wait > 0):\n wait = wait - 0.1\n time.sleep(0.1)\n recv_data = lora_sock.recv(64)\n\n if (len (recv_data) >= 2):\n status, device_id = struct.unpack(LORA_CONFIRM_FORMAT, recv_data)\n\n if (device_id == DEVICE_ID and status == 200):\n pycom.rgbled(0x001500)\n wait = 0\n\n time.sleep(1)\n\n"},"tutorials/all/owd.html":{"url":"tutorials/all/owd.html","title":"Onewire Driver","keywords":"","body":"Onewire Driver\nThis tutorial explains how to connect and read data from a DS18x20 temperature sensor. The onewire library is also available at the pycom-libraries GitHub Repository.\nBasic usage\nimport time\nfrom machine import Pin\nfrom onewire import DS18X20\nfrom onewire import OneWire\n\n# DS18B20 data line connected to pin P10\now = OneWire(Pin('P10'))\ntemp = DS18X20(ow)\n\nwhile True:\n print(temp.read_temp_async())\n time.sleep(1)\n temp.start_conversion()\n time.sleep(1)\n\nLibrary\n#!/usr/bin/env python3\n\n\"\"\"\nOneWire library for MicroPython\n\"\"\"\n\nimport time\nimport machine\n\nclass OneWire:\n CMD_SEARCHROM = const(0xf0)\n CMD_READROM = const(0x33)\n CMD_MATCHROM = const(0x55)\n CMD_SKIPROM = const(0xcc)\n\n def __init__(self, pin):\n self.pin = pin\n self.pin.init(pin.OPEN_DRAIN, pin.PULL_UP)\n\n def reset(self):\n \"\"\"\n Perform the onewire reset function.\n Returns True if a device asserted a presence pulse, False otherwise.\n \"\"\"\n sleep_us = time.sleep_us\n disable_irq = machine.disable_irq\n enable_irq = machine.enable_irq\n pin = self.pin\n\n pin(0)\n sleep_us(480)\n i = disable_irq()\n pin(1)\n sleep_us(60)\n status = not pin()\n enable_irq(i)\n sleep_us(420)\n return status\n\n def read_bit(self):\n sleep_us = time.sleep_us\n enable_irq = machine.enable_irq\n pin = self.pin\n\n pin(1) # half of the devices don't match CRC without this line\n i = machine.disable_irq()\n pin(0)\n sleep_us(1)\n pin(1)\n sleep_us(1)\n value = pin()\n enable_irq(i)\n sleep_us(40)\n return value\n\n def read_byte(self):\n value = 0\n for i in range(8):\n value |= self.read_bit() >= 1\n\n def write_bytes(self, buf):\n for b in buf:\n self.write_byte(b)\n\n def select_rom(self, rom):\n \"\"\"\n Select a specific device to talk to. Pass in rom as a bytearray (8 bytes).\n \"\"\"\n self.reset()\n self.write_byte(CMD_MATCHROM)\n self.write_bytes(rom)\n\n def crc8(self, data):\n \"\"\"\n Compute CRC\n \"\"\"\n crc = 0\n for i in range(len(data)):\n byte = data[i]\n for b in range(8):\n fb_bit = (crc ^ byte) & 0x01\n if fb_bit == 0x01:\n crc = crc ^ 0x18\n crc = (crc >> 1) & 0x7f\n if fb_bit == 0x01:\n crc = crc | 0x80\n byte = byte >> 1\n return crc\n\n def scan(self):\n \"\"\"\n Return a list of ROMs for all attached devices.\n Each ROM is returned as a bytes object of 8 bytes.\n \"\"\"\n devices = []\n diff = 65\n rom = False\n for i in range(0xff):\n rom, diff = self._search_rom(rom, diff)\n if rom:\n devices += [rom]\n if diff == 0:\n break\n return devices\n\n def _search_rom(self, l_rom, diff):\n if not self.reset():\n return None, 0\n self.write_byte(CMD_SEARCHROM)\n if not l_rom:\n l_rom = bytearray(8)\n rom = bytearray(8)\n next_diff = 0\n i = 64\n for byte in range(8):\n r_b = 0\n for bit in range(8):\n b = self.read_bit()\n if self.read_bit():\n if b: # there are no devices or there is an error on the bus\n return None, 0\n else:\n if not b: # collision, two devices with different bit meaning\n if diff > i or ((l_rom[byte] & (1 > 1 | 0x80 # truncate bit 0 by shifting, fill high bit with 1.\n temp_read = -((~temp_read + 1) & 0xff) # now convert from two's complement\n else:\n temp_read = temp_lsb >> 1 # truncate bit 0 by shifting\n count_remain = data[6]\n count_per_c = data[7]\n temp = 100 * temp_read - 25 + (count_per_c - count_remain) // count_per_c\n return temp\n elif rom0 == 0x28:\n return (temp_msb \n"},"tutorials/all/threading.html":{"url":"tutorials/all/threading.html","title":"Threading","keywords":"","body":"Threading\nMicroPython supports spawning threads by the _thread module. The following example demonstrates the use of this module. A thread is simply defined as a function that can receive any number of parameters. Below 3 threads are started, each one perform a print at a different interval.\nimport _thread\nimport time\n\ndef th_func(delay, id):\n while True:\n time.sleep(delay)\n print('Running thread %d' % id)\n\nfor i in range(3):\n _thread.start_new_thread(th_func, (i + 1, i))\n\nUsing Locks:\nimport _thread\n\na_lock = _thread.allocate_lock()\n\nwith a_lock:\n print(\"a_lock is locked while this executes\")\n\n"},"tutorials/all/rgbled.html":{"url":"tutorials/all/rgbled.html","title":"RGB LED","keywords":"","body":"RGB LED\nBy default the heartbeat LED flashes in blue colour once every 4s to signal that the system is alive. This can be overridden through the pycom module.\nimport pycom\n\npycom.heartbeat(False)\npycom.rgbled(0xff00) # turn on the RGB LED in green colour\n\nThe heartbeat LED is also used to indicate that an error was detected.\nThe following piece of code uses the RGB LED to make a traffic light that runs for 10 cycles.\nimport pycom\nimport time\n\npycom.heartbeat(False)\nfor cycles in range(10): # stop after 10 cycles\n pycom.rgbled(0x007f00) # green\n time.sleep(5)\n pycom.rgbled(0x7f7f00) # yellow\n time.sleep(1.5)\n pycom.rgbled(0x7f0000) # red\n time.sleep(4)\n\nHere is the expected result:\n\n"},"tutorials/all/timers.html":{"url":"tutorials/all/timers.html","title":"Timers","keywords":"","body":"Timers\nDetailed information about this class can be found in Timer.\nChronometer\nThe Chronometer can be used to measure how much time has elapsed in a block of code. The following example uses a simple stopwatch.\nfrom machine import Timer\nimport time\n\nchrono = Timer.Chrono()\n\nchrono.start()\ntime.sleep(1.25) # simulate the first lap took 1.25 seconds\nlap = chrono.read() # read elapsed time without stopping\ntime.sleep(1.5)\nchrono.stop()\ntotal = chrono.read()\n\nprint()\nprint(\"\\nthe racer took %f seconds to finish the race\" % total)\nprint(\" %f seconds in the first lap\" % lap)\nprint(\" %f seconds in the last lap\" % (total - lap))\n\nAlarm\nThe Alarm can be used to get interrupts at a specific interval. The following code executes a callback every second for 10 seconds.\nfrom machine import Timer\n\nclass Clock:\n\n def __init__(self):\n self.seconds = 0\n self.__alarm = Timer.Alarm(self._seconds_handler, 1, periodic=True)\n\n def _seconds_handler(self, alarm):\n self.seconds += 1\n print(\"%02d seconds have passed\" % self.seconds)\n if self.seconds == 10:\n alarm.callback(None) # stop counting after 10 seconds\n\nclock = Clock()\n\nThere are no restrictions to what can be done in an interrupt. For example, it is possible to even do network requests with an interrupt. However, it is important to keep in mind that interrupts are handled sequentially, so it's good practice to keep them short. More information can be found in Interrupt Handling.\n\n"},"tutorials/all/pir.html":{"url":"tutorials/all/pir.html","title":"PIR Sensor","keywords":"","body":"PIR Sensor\nThis code reads PIR sensor triggers from this simple PIR sensor and sends an HTTP request for every trigger, in this case to a Domoticz installation. When motion is constantly detected, this PIR sensor keeps the pin high, in which case this code will keep sending HTTP requests every 10 seconds (configurable with the hold_time variable).\nMain (main.py)\nimport time\nfrom network import WLAN\nfrom machine import Pin\nfrom domoticz import Domoticz\n\nwl = WLAN(WLAN.STA)\nd = Domoticz(\"\", 8080 ,\"\")\n\n#config\nhold_time_sec = 10\n\n#flags\nlast_trigger = -10\n\npir = Pin('G4',mode=Pin.IN, pull=Pin.PULL_UP)\n\n# main loop\nprint(\"Starting main loop\")\nwhile True:\n if pir() == 1:\n if time.time() - last_trigger > hold_time_sec:\n last_trigger = time.time()\n print(\"Presence detected, sending HTTP request\")\n try:\n return_code = d.setVariable('Presence:LivingRoom','1')\n print(\"Request result: \"+str(return_code))\n except Exception as e:\n print(\"Request failed\")\n print(e)\n else:\n last_trigger = 0\n print(\"No presence\")\n\n time.sleep_ms(500)\n\nprint(\"Exited main loop\")\n\nBoot (boot.py)\nFor more WiFi scripts, see the wlan step by step tutorial.\nimport os\nimport machine\n\nuart = machine.UART(0, 115200)\nos.dupterm(uart)\n\nknown_nets = {\n 'NetworkID': {'pwd': '', 'wlan_config': ('10.0.0.8', '255.255.0.0', '10.0.0.1', '10.0.0.1')},\n}\n\nfrom network import WLAN\nwl = WLAN()\n\n\nif machine.reset_cause() != machine.SOFT_RESET:\n\n wl.mode(WLAN.STA)\n original_ssid = wl.ssid()\n original_auth = wl.auth()\n\n print(\"Scanning for known wifi nets\")\n available_nets = wl.scan()\n nets = frozenset([e.ssid for e in available_nets])\n\n known_nets_names = frozenset([key for key in known_nets])\n net_to_use = list(nets & known_nets_names)\n try:\n net_to_use = net_to_use[0]\n net_properties = known_nets[net_to_use]\n pwd = net_properties['pwd']\n sec = [e.sec for e in available_nets if e.ssid == net_to_use][0]\n if 'wlan_config' in net_properties:\n wl.ifconfig(config=net_properties['wlan_config'])\n wl.connect(net_to_use, (sec, pwd), timeout=10000)\n while not wl.isconnected():\n machine.idle() # save power while waiting\n print(\"Connected to \"+net_to_use+\" with IP address:\" + wl.ifconfig()[0])\n\n except Exception as e:\n print(\"Failed to connect to any known network, going into AP mode\")\n wl.init(mode=WLAN.AP, ssid=original_ssid, auth=original_auth, channel=6, antenna=WLAN.INT_ANT)\n\nDomoticz Wrapper (domoticz.py)\nimport socket\nclass Domoticz:\n\n def __init__(self, ip, port, basic):\n self.basic = basic\n self.ip = ip\n self.port = port\n\n def setLight(self, idx, command):\n return self.sendRequest(\"type=command¶m=switchlight&idx=\"+idx+\"&switchcmd=\"+command)\n\n def setVariable(self, name, value):\n return self.sendRequest(\"type=command¶m=updateuservariable&vtype=0&vname=\"+name+\"&vvalue=\"+value)\n\n def sendRequest(self, path):\n try:\n s = socket.socket()\n s.connect((self.ip,self.port))\n s.send(b\"GET /json.htm?\"+path+\" HTTP/1.1\\r\\nHost: pycom.io\\r\\nAuthorization: Basic \"+self.basic+\"\\r\\n\\r\\n\")\n status = str(s.readline(), 'utf8')\n code = status.split(\" \")[1]\n s.close()\n return code\n\n except Exception:\n print(\"HTTP request failed\")\n return 0\n\n"},"tutorials/all/modbus.html":{"url":"tutorials/all/modbus.html","title":"Modbus","keywords":"","body":"Modbus\nModbus is a messaging protocol that defines the packet structure for transferring data between devices in a master/slave architecture. The protocol is independent of the transmission medium and is usually transmitted over TCP (MODBUS TCP) or serial communication (MODBUS RTU). Modbus is intended as a request/reply protocol and delivers services specified by function codes. The function code in the request tells the addressed slave what kind of action to perform. The function codes most commonly supported by devices are listed below.\n\n\n\nFunction Name\nFunction Code\n\n\n\n\nRead Coils\n0x01\n\n\nRead Discrete Inputs\n0x02\n\n\nRead Holding Registers\n0x03\n\n\nRead Input Registers\n0x04\n\n\nWrite Single Coil\n0x05\n\n\nWrite Single Register\n0x06\n\n\nWrite Multiple Coils\n0x0F\n\n\nWrite Multiple Registers\n0x10\n\n\n\nFor more information on the MODBUS RTU see the following PDF File. Information on the MODBUS TCP can be found here.\nPycom Modbus Library\nPython libraries and sample code that support Modbus TCP and Modbus RTU are available at the following GitHub Repository. To use this library, connect to the target Pycom device via ftp and upload the uModbus folder to /flash. A description of the supported function codes is found below.\nRead Coils\nThis function code requests the status (ON/OFF) of discrete coils on a remote device. The slave device address, the address of the first coil and the number of coils must be specified in the request. The address of the first coil is 0 and a maximum of 2000 contiguous coils can be read. Python sample code is shown below.\nslave_addr=0x0A\nstarting_address=0x00\ncoil_quantity=100\n\ncoil_status = modbus_obj.read_coils(slave_addr, starting_address, coil_quantity)\nprint('Coil status: ' + ' '.join('{:d}'.format(x) for x in coil_status))\n\nRead Discrete Inputs\nThis command is used to read the status (ON/OFF) of discrete inputs on a remote device. The slave address, the address of the first input, and the quantity of inputs to be read must be specified. The address of the first input is 0 and a maximum of 2000 continuous inputs can be read. The Python sample code is shown below.\nslave_addr=0x0A\nstarting_address=0x0\ninput_quantity=100\n\ninput_status = modbus_obj.read_discrete_inputs(slave_addr, starting_address, input_quantity)\nprint('Input status: ' + ' '.join('{:d}'.format(x) for x in input_status))\n\nRead Holding Registers\nThis function code is used to read the contents of analogue output holding registers. The slave address, the starting register address, the number of registers to read and the sign of the data must be specified. Register addresses start at 0 and a maximum of 125 continuous registers can be read.\nslave_addr=0x0A\nstarting_address=0x00\nregister_quantity=100\nsigned=True\n\nregister_value = modbus_obj.read_holding_registers(slave_addr, starting_address, register_quantity, signed)\nprint('Holding register value: ' + ' '.join('{:d}'.format(x) for x in register_value))\n\nRead Input Registers\nThis command is used to read up to 125 continuous input registers on a remote device. The slave address, the starting register address, the number of input registers and the sign of the data must be specified. The address of the first input registers is 0.\nslave_addr=0x0A\nstarting_address=0x00\nregister_quantity=100\nsigned=True\n\nregister_value = modbus_obj.read_input_registers(slave_addr, starting_address, register_quantity, signed)\nprint('Input register value: ' + ' '.join('{:d}'.format(x) for x in register_value))\n\nWrite Single Coil\nThis function code is used to write the state of a discrete coil on a remote device. A value of 0xFF00 means the coil should be set to ON, while a value of 0x0000 means the coil should be set to OFF. The Python sample code to set the coil at address 0x00, to an ON state is shown below.\nslave_addr=0x0A\noutput_address=0x00\noutput_value=0xFF00\n\nreturn_flag = modbus_obj.write_single_coil(slave_addr, output_address, output_value)\noutput_flag = 'Success' if return_flag else 'Failure'\nprint('Writing single coil status: ' + output_flag)\n\nWrite Single Register\nThis command is used to write the contents of an analog output holding register on a remote device. The slave address, the register address, the register value, and the signature of the data must be specified. As for all the other commands, the register addresses start from 0.\nslave_addr=0x0A\nregister_address=0x01\nregister_value=-32768\nsigned=True\n\nreturn_flag = modbus_obj.write_single_register(slave_addr, register_address, register_value, signed)\noutput_flag = 'Success' if return_flag else 'Failure'\nprint('Writing single coil status: ' + output_flag)\n\nWrite Multiple Coils\nThis function code is used to set a continuous sequence of coils, in a remote device, to either ON or OFF. The slave address, the starting address of the coils and an array with the coil states must be specified.\nslave_addr=0x0A\nstarting_address=0x00\noutput_values=[1,1,1,0,0,1,1,1,0,0,1,1,1]\n\nreturn_flag = modbus_obj.write_multiple_coils(slave_addr, starting_address, output_values)\noutput_flag = 'Success' if return_flag else 'Failure'\nprint('Writing multiple coil status: ' + output_flag)\n\nWrite Multiple Registers\nThis command is used to write the contents of a continuous sequence of analogue registers on a remote device. The slave address, the starting register address, the register values, and the signature of the data must be specified. The address of the first register is 0 and a maximum of 125 register values can be written. The Python sample code is shown below.\nslave_addr=0x0A\nregister_address=0x01\nregister_values=[2, -4, 6, -256, 1024]\nsigned=True\n\nreturn_flag = modbus_obj.write_multiple_registers(slave_addr, register_address, register_values, signed)\noutput_flag = 'Success' if return_flag else 'Failure'\nprint('Writing multiple register status: ' + output_flag)\n\n"},"tutorials/all/ota.html":{"url":"tutorials/all/ota.html","title":"OTA update","keywords":"","body":"OTA update\nOverview\nPycom modules come with the ability to update the devices firmware, while it is still running, we call this an \"over the air\" (OTA) update. The pycom library provides several functions to achieve this. This example will demonstrate how you could potentially use this functionality to update deployed devices. The full source code of this example can be found here.\nMethod\nHere we will describe one possible update methodology you could use that is implemented by this example.\nImagine you a smart metering company and you wish to roll out an update for your Pycom based smart meter. These meters usually send data back via LoRa. Unfortunately LoRa downlink messages have a very limited size and several hundred if not thousand would be required to upload a complete firmware image. To get around this you can have your devices sending their regular data via LoRa and when they receive a special command via a downlink message, the devices will connect to a WiFi network. It is unfeasible to ask customers to allow your device to connect to their home network so instead this network could be provided by a vehicle. This vehicle will travel around a certain geographic area in which the devices have been sent the special downlink message to initiate the update. The devices will look for the WiFi network being broadcast by the vehicle and connect. The devices will then connect to a server running on this WiFi network. This server (also shown in this example) will generate manifest files that instruct the device on what it should update, and where to get the update data from.\nServer\nCode available here.\nThis script runs a HTTP server on port 8000 that provisions over the air (OTA) update manifests in JSON format as well as serving the update content. This script should be run in a directory that contains every version of the end devices code, in the following structure:\n - server directory\n |- this_script.py\n |- 1.0.0\n | |- flash\n | | |- lib\n | | | |- lib_a.py\n | | |- main.py\n | | |- boot.py\n | |- sd\n | |- some_asset.txt\n | |- asset_that_will_be_removed.wav\n |- 1.0.1\n | |- flash\n | | |- lib\n | | | |- lib_a.py\n | | | |- new_lib.py\n | | |- main.py\n | | |- boot.py\n | |- sd\n | |- some_asset.txt\n |- firmware_1.0.0.bin\n |- firmware_1.0.1.bin\n\nThe top level directory that contains this script can contain one of two things:\n\nUpdate directory: These should be named with a version number compatible\nwith the python LooseVersion versioning scheme\n(http://epydoc.sourceforge.net/stdlib/distutils.version.LooseVersion-class.html).\nThey should contain the entire file system of the end device for the\ncorresponding version number.\n\nFirmware: These files should be named in the format firmare_VERSION.bin, where VERSION is a a version number compatible with the python LooseVersion versioning scheme (http://epydoc.sourceforge.net/stdlib/distutils.version.LooseVersion-class.html).\nThis file should be in the format of the appimg.bin created by the Pycom\nfirmware build scripts.\n\n\nHow to use\nOnce the directory has been setup as described above you simply need to start this script using python3. Once started this script will run a HTTP server on port 8000 (this can be changed by changing the PORT variable). This server will serve all the files in directory as expected along with one additional special file, manifest.json. This file does not exist on the file system but is instead generated when requested and contains the required changes to bring the end device from its current version to the latest available version. You can see an example of this by pointing your web browser at:\nhttp://127.0.0.1:8000/manifest.json?current_ver=1.0.0\nThe current_ver field at the end of the URL should be set to the current firmware version of the end device. The generated manifest will contain lists of which files are new, have changed or need to be deleted along with SHA1 hashes of the files. Below is an example of what such a manifest might look like:\n{\n \"delete\": [\n \"flash/old_file.py\",\n \"flash/other_old_file.py\"\n ],\n \"firmware\": {\n \"URL\": \"http://192.168.1.144:8000/firmware_1.0.1b.bin\",\n \"hash\": \"ccc6914a457eb4af8855ec02f6909316526bdd08\"\n },\n \"new\": [\n {\n \"URL\": \"http://192.168.1.144:8000/1.0.1b/flash/lib/new_lib.py\",\n \"dst_path\": \"flash/lib/new_lib.py\",\n \"hash\": \"1095df8213aac2983efd68dba9420c8efc9c7c4a\"\n }\n ],\n \"update\": [\n {\n \"URL\": \"http://192.168.1.144:8000/1.0.1b/flash/changed_file.py\",\n \"dst_path\": \"flash/changed_file.py\",\n \"hash\": \"1095df8213aac2983efd68dba9420c8efc9c7c4a\"\n }\n ],\n \"version\": \"1.0.1b\"\n}\n\nThe manifest contains the following fields:\n\ndelete: A list of paths to files which are no longer needed\nfirmware: The URL and SHA1 hash of the firmware image\nnew: the URL, path on end device and SHA1 hash of all new files\nupdate: the URL, path on end device and SHA1 hash of all files which\nexisted before but have changed.\n\nversion: The version number that this manifest will update the client to\n\nprevious_version: The version the client is currently on before applying\nthis update\n\n\nNote: The version number of the files might not be the same as the firmware. The highest available version number, higher than the current client version is used for both firmware and files. This may differ between the two.\nIn order for the URL's to be properly formatted you are required to send a \"host\" header along with your HTTP get request e.g:\nGET /manifest.json?current_ver=1.0.0 HTTP/1.0\\r\\nHost: 192.168.1.144:8000\\r\\n\\r\\n\n\nClient Library\nA MicroPyton library for interfacing with the server described above is available here.\nThis library is split into two layers. The top level OTA class implements all the high level functionality such as parsing the JSON file, making back copies of files being updated incase the update fails, etc. The layer of the library is agnostic to your chosen transport method. Below this is the WiFiOTA class. This class implements the actual transport mechanism of how the device fetches the files and update manifest (via WiFi as the class name suggests). The reason for this split is so that the high level functionality can be reused regardless of what transport mechanism you end up using. This could be implemented on top of Bluetooth for example, or the sever changed from HTTP to FTP.\nAlthough the above code is functional, it is provided only as an example of how an end user might implement a OTA update mechanism. It is not 100% feature complete e.g. even though it does backup previous versions of files, the roll back procedure is not implemented. This is left of the end user to do.\n\nExample\nBelow is am example implementing the methodology previously explained in this tutorial to initiate an OTA update.\nThe example below will only work on a Pycom device with LoRa capabilities. If want to test it out on a device without LoRa functionality then simply comment out any code relating to LoRa. Leaving just the WiFiOTA initialisation and they ota.connect() and ota.update()\n\nfrom network import LoRa, WLAN\nimport socket\nimport time\nfrom OTA import WiFiOTA\nfrom time import sleep\nimport pycom\nimport ubinascii\n\nfrom config import WIFI_SSID, WIFI_PW, SERVER_IP\n\n# Turn on GREEN LED\npycom.heartbeat(False)\npycom.rgbled(0xff00)\n\n# Setup OTA\nota = WiFiOTA(WIFI_SSID,\n WIFI_PW,\n SERVER_IP, # Update server address\n 8000) # Update server port\n\n# Turn off WiFi to save power\nw = WLAN()\nw.deinit()\n\n# Initialise LoRa in LORAWAN mode.\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\napp_eui = ubinascii.unhexlify('70B3D57ED0008CD6')\napp_key = ubinascii.unhexlify('B57F36D88691CEC5EE8659320169A61C')\n\n# join a network using OTAA (Over the Air Activation)\nlora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)\n\n# wait until the module has joined the network\nwhile not lora.has_joined():\n time.sleep(2.5)\n print('Not yet joined...')\n\n# create a LoRa socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\n# set the LoRaWAN data rate\ns.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)\n\n# make the socket blocking\n# (waits for the data to be sent and for the 2 receive windows to expire)\ns.setblocking(True)\n\nwhile True:\n # send some data\n s.send(bytes([0x04, 0x05, 0x06]))\n\n # make the socket non-blocking\n # (because if there's no data received it will block forever...)\n s.setblocking(False)\n\n # get any data received (if any...)\n data = s.recv(64)\n\n # Some sort of OTA trigger\n if data == bytes([0x01, 0x02, 0x03]):\n print(\"Performing OTA\")\n # Perform OTA\n ota.connect()\n ota.update()\n\n sleep(5)\n\n"},"tutorials/all/rmt.html":{"url":"tutorials/all/rmt.html","title":"RMT","keywords":"","body":"RMT\nDetailed information about this class can be found in RMT.\nThe RMT (Remote Control) peripheral of the ESP32 is primarily designed to send and receive infrared remote control signals that use on-off-keying of a carrier frequency, but due to its design it can be used to generate various types of signals, this class will allow you to do this.\nThe RMT has 7 channels, of which 5 are available and can be mapped to any GPIO pin (Note: Pins P13 -P18 can only be used as inputs).\n\n\n\nChannel\nResolution\nMaximum Pulse Width\n\n\n\n\n0\nUsed by on-board LED\n\n\n\n1\nUsed by pycom.pulses_get()\n\n\n\n2\n100nS\n3.2768 ms\n\n\n3\n100nS\n3.2768 ms\n\n\n4\n1000nS\n32.768 ms\n\n\n5\n1000nS\n32.768 ms\n\n\n6\n3125nS\n102.4 ms\n\n\n7\n3125nS\n102.4 ms\n\n\n\nTransmitting\nThe following examples create an RMT object on channel 4, configure it for transmission and send some data in various forms. The resolution of channel 4 is 1000 nano seconds, the given values are interpreted accordingly.\nIn this first example, we define the signal as a tuple of binary values that define the shape of the desired signal along with the duration of a bit.\nfrom machine import RMT\n# Map RMT channel 4 to P21, when the RMT is idle, it will output LOW\nrmt = RMT(channel=4, gpio=\"P21\", tx_idle_level=RMT.LOW)\n\n# Produces the pattern shown in data, where each bit lasts\n# duration * channel resolution = 10000 * 1000ns = 10ms\ndata = (1,0,1,1,1,0,1,0,1)\nduration = 10000\nrmt.pulses_send(duration, data)\n\n\nIn this example we define the signal by a tuple of durations and what state the signal starts in.\nfrom machine import RMT\n# Map RMT channel 4 to P21, when the RMT is idle, it will output LOW\nrmt = RMT(channel=4, gpio=\"P21\", tx_idle_level=RMT.LOW)\n\n# The list of durations for each pulse to be, these are in units of the channels\n# resolution:\n# duration = Desired pulse length / Channel Resolution\nduration = (8000,11000,8000,11000,6000,13000,6000,3000,8000)\n\n# `start_level` defines if the signal starts off as LOW or HIGH, it will then\n# toggle state between each duration\nrmt.pulses_send(duration, start_level=RMT.HIGH)\n\n\nThis third example, is a combination of the above two styles of defining a signal. Each pulse has a defined duration as well as a state. This is useful if you don't always want the signal to toggle state.\nfrom machine import RMT\n# Map RMT channel 4 to P21, when the RMT is idle, it will output LOW\nrmt = RMT(channel=4, gpio=\"P21\", tx_idle_level=RMT.LOW)\n\n# Produces the pattern shown in data, where each bit lasts\n# duration[i] * channel resolution = duration[i] * 1000ns\ndata = (1,0,1,1,0,1)\nduration = (400,200,100,300,200,400)\nrmt.pulses_send(duration, data)\n\n\nThe following example creates an RMT object on channel 4 and configures it for transmission with carrier modulation.\nfrom machine import RMT\nrmt = RMT(channel=4,\n gpio=\"P21\",\n tx_idle_level=RMT.LOW,\n # Carrier = 100Hz, 80% duty, modules HIGH signals\n tx_carrier = (100, 70, RMT.HIGH)) \ndata = (1,0,1)\nduration = 10000\nrmt.pulses_send(duration, data)\n\n\nThe following example creates an RMT object on channel 2, configures it for receiving, then waits for the first, undefined number of pulses without timeout\nfrom machine import RMT\nrmt = machine.RMT(channel=2)\nrmt.init(gpio=\"P21\", rx_idle_threshold=1000)\n\ndata = rmt.pulses_get()\n\nIf tx_idle_level is not set to the opposite of the third value in the tx_carrier tuple, the carrier wave will continue to be generated when the RMT channel is idle.\n\nReceiving\nThe following example creates an RMT object on channel 2, configures it for receiving a undefined number of pulses, then waits maximum of 1000us for the first pulse.\nfrom machine import RMT\n# Sets RMT channel 2 to P21 and sets the maximum length of a valid pulse to\n# 1000*channel resolution = 1000 * 100ns = 100us\nrmt = machine.RMT(channel=2, gpio=\"P21\", rx_idle_threshold=1000)\nrmt.init()\n\n# Get a undefined number of pulses, waiting a maximum of 500us for the first\n# pulse (unlike other places where the absolute duration was based on the RMT\n# channels resolution, this value is in us) until a pulse longer than\n# rx_idle_threshold occurs.\ndata = rmt.pulses_get(timeout=500)\n\nThe following example creates an RMT object on channel 2, configures it for receiving, filters out pulses with width \nfrom machine import RMT\n\nrmt = machine.RMT(channel=2, # Resolution = 100ns\n gpio=\"P21\",\n # Longest valid pulse = 1000*100ns = 100us\n rx_idle_threshold=1000,\n # Filter out pulses shorter than 20*100ns = 2us\n rx_filter_threshold=20)\n\n# Receive 100 pulses, pulses shorter than 2us or longer than 100us will be\n# ignored. That means if it receives 80 valid pulses but then the signal\n# doesn't change for 10 hours and then 20 more pulses occur, this function\n# will wait for 10h\ndata = rmt.pulses_get(pulses=100)\n\n"},"tutorials/lora/":{"url":"tutorials/lora/","title":"LoRa Examples","keywords":"","body":"LoRa Examples\nThe following tutorials demonstrate the use of the LoRa functionality on the LoPy. LoRa can work in 2 different modes; LoRa-MAC (which we also call Raw-LoRa) and LoRaWAN mode.\nLoRa-MAC mode basically accesses de radio directly and packets are sent using the LoRa modulation on the selected frequency without any headers, addressing information or encryption. Only a CRC is added at the tail of the packet and this is removed before the received frame is passed on to the application. This mode can be used to build any higher level protocol that can benefit from the long range features of the LoRa modulation. Typical uses cases include LoPy to LoPy direct communication and a LoRa packet forwarder.\nLoRaWAN mode implements the full LoRaWAN stack for a class A device. It supports both OTAA and ABP connection methods, as well as advanced features like adding and removing custom channels to support \"special\" frequencies plans like the those used in New Zealand.\n"},"tutorials/lora/lora-mac.html":{"url":"tutorials/lora/lora-mac.html","title":"LoRa-MAC (Raw LoRa)","keywords":"","body":"LoRa-MAC (Raw LoRa)\nBasic LoRa connection example, sending and receiving data. In LoRa-MAC mode the LoRaWAN layer is bypassed and the radio is used directly. The data sent is not formatted or encrypted in any way, and no addressing information is added to the frame.\nFor the example below, you will need two LoPys. A while loop with a random delay time is used to minimise the chances of the 2 LoPy's transmitting at the same time. Run the code below on the 2 LoPy modules and you will see the word 'Hello' being received on both sides.\nfrom network import LoRa\nimport socket\nimport machine\nimport time\n\n# initialise LoRa in LORA mode\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\n# more params can also be given, like frequency, tx power and spreading factor\nlora = LoRa(mode=LoRa.LORA, region=LoRa.EU868)\n\n# create a raw LoRa socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\nwhile True:\n # send some data\n s.setblocking(True)\n s.send('Hello')\n\n # get any data received...\n s.setblocking(False)\n data = s.recv(64)\n print(data)\n\n # wait a random amount of time\n time.sleep(machine.rng() & 0x0F)\n\n"},"tutorials/lora/lorawan-otaa.html":{"url":"tutorials/lora/lorawan-otaa.html","title":"LoRaWAN with OTAA","keywords":"","body":"LoRaWAN with OTAA\nOTAA stands for Over The Air Authentication. With this method the LoPy sends a Join request to the LoRaWAN Gateway using the APPEUI and APPKEY provided. If the keys are correct the Gateway will reply to the LoPy with a join accept message and from that point on the LoPy is able to send and receive packets to/from the Gateway. If the keys are incorrect no response will be received and the has_joined() method will always return False.\nThe example below attempts to get any data received after sending the frame. Keep in mind that the Gateway might not be sending any data back, therefore we make the socket non-blocking before attempting to receive, in order to prevent getting stuck waiting for a packet that will never arrive.\nfrom network import LoRa\nimport socket\nimport time\nimport ubinascii\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\n# create an OTAA authentication parameters\napp_eui = ubinascii.unhexlify('ADA4DAE3AC12676B')\napp_key = ubinascii.unhexlify('11B0282A189B75B0B4D2D8C7FA38548B')\n\n# join a network using OTAA (Over the Air Activation)\nlora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)\n\n# wait until the module has joined the network\nwhile not lora.has_joined():\n time.sleep(2.5)\n print('Not yet joined...')\n\n# create a LoRa socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\n# set the LoRaWAN data rate\ns.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)\n\n# make the socket blocking\n# (waits for the data to be sent and for the 2 receive windows to expire)\ns.setblocking(True)\n\n# send some data\ns.send(bytes([0x01, 0x02, 0x03]))\n\n# make the socket non-blocking\n# (because if there's no data received it will block forever...)\ns.setblocking(False)\n\n# get any data received (if any...)\ndata = s.recv(64)\nprint(data)\n\n"},"tutorials/lora/lorawan-abp.html":{"url":"tutorials/lora/lorawan-abp.html","title":"LoRaWAN with ABP","keywords":"","body":"LoRaWAN with ABP\nABP stands for Authentication By Personalisation. It means that the encryption keys are configured manually on the device and can start sending frames to the Gateway without needing a 'handshake' procedure to exchange the keys (such as the one performed during an OTAA join procedure).\nThe example below attempts to get any data received after sending the frame. Keep in mind that the Gateway might not be sending any data back, therefore we make the socket non-blocking before attempting to receive, in order to prevent getting stuck waiting for a packet that will never arrive.\nfrom network import LoRa\nimport socket\nimport ubinascii\nimport struct\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\n# create an ABP authentication params\ndev_addr = struct.unpack(\">l\", ubinascii.unhexlify('00000005'))[0]\nnwk_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\napp_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\n\n# join a network using ABP (Activation By Personalization)\nlora.join(activation=LoRa.ABP, auth=(dev_addr, nwk_swkey, app_swkey))\n\n# create a LoRa socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\n# set the LoRaWAN data rate\ns.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)\n\n# make the socket blocking\n# (waits for the data to be sent and for the 2 receive windows to expire)\ns.setblocking(True)\n\n# send some data\ns.send(bytes([0x01, 0x02, 0x03]))\n\n# make the socket non-blocking\n# (because if there's no data received it will block forever...)\ns.setblocking(False)\n\n# get any data received (if any...)\ndata = s.recv(64)\nprint(data)\n\n"},"tutorials/lora/lora-mac-nano-gateway.html":{"url":"tutorials/lora/lora-mac-nano-gateway.html","title":"LoRa-MAC Nano-Gateway","keywords":"","body":"LoRa-MAC Nano-Gateway\nThis example allows a raw LoRa connection between two LoPys (nodes) to a single LoPy acting as a Nano-Gateway.\nFor more information and discussions about this code, see this forum post.\nGateway Code\nimport socket\nimport struct\nfrom network import LoRa\n\n# A basic package header, B: 1 byte for the deviceId, B: 1 byte for the pkg size, %ds: Formatted string for string\n_LORA_PKG_FORMAT = \"!BB%ds\"\n# A basic ack package, B: 1 byte for the deviceId, B: 1 byte for the pkg size, B: 1 byte for the Ok (200) or error messages\n_LORA_PKG_ACK_FORMAT = \"BBB\"\n\n# Open a LoRa Socket, use rx_iq to avoid listening to our own messages\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORA, rx_iq=True, region=LoRa.EU868)\nlora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\nlora_sock.setblocking(False)\n\nwhile (True):\n recv_pkg = lora_sock.recv(512)\n if (len(recv_pkg) > 2):\n recv_pkg_len = recv_pkg[1]\n\n device_id, pkg_len, msg = struct.unpack(_LORA_PKG_FORMAT % recv_pkg_len, recv_pkg)\n\n# If the uart = machine.UART(0, 115200) and os.dupterm(uart) are set in the boot.py this print should appear in the serial port\n print('Device: %d - Pkg: %s' % (device_id, msg))\n\n ack_pkg = struct.pack(_LORA_PKG_ACK_FORMAT, device_id, 1, 200)\n lora_sock.send(ack_pkg)\n\nThe _LORA_PKG_FORMAT is used as a method of identifying the different devices within a network. The _LORA_PKG_ACK_FORMAT is a simple ack package as a response to the nodes package.\nNode\nimport os\nimport socket\nimport time\nimport struct\nfrom network import LoRa\n\n# A basic package header, B: 1 byte for the deviceId, B: 1 byte for the pkg size\n_LORA_PKG_FORMAT = \"BB%ds\"\n_LORA_PKG_ACK_FORMAT = \"BBB\"\nDEVICE_ID = 0x01\n\n\n# Open a Lora Socket, use tx_iq to avoid listening to our own messages\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORA, tx_iq=True, region=LoRa.EU868)\nlora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\nlora_sock.setblocking(False)\n\nwhile(True):\n # Package send containing a simple string\n msg = \"Device 1 Here\"\n pkg = struct.pack(_LORA_PKG_FORMAT % len(msg), DEVICE_ID, len(msg), msg)\n lora_sock.send(pkg)\n\n # Wait for the response from the gateway. NOTE: For this demo the device does an infinite loop for while waiting the response. Introduce a max_time_waiting for you application\n waiting_ack = True\n while(waiting_ack):\n recv_ack = lora_sock.recv(256)\n\n if (len(recv_ack) > 0):\n device_id, pkg_len, ack = struct.unpack(_LORA_PKG_ACK_FORMAT, recv_ack)\n if (device_id == DEVICE_ID):\n if (ack == 200):\n waiting_ack = False\n # If the uart = machine.UART(0, 115200) and os.dupterm(uart) are set in the boot.py this print should appear in the serial port\n print(\"ACK\")\n else:\n waiting_ack = False\n # If the uart = machine.UART(0, 115200) and os.dupterm(uart) are set in the boot.py this print should appear in the serial port\n print(\"Message Failed\")\n\n time.sleep(5)\n\nThe node is always sending packages and waiting for the ack from the gateway.\nTo adapt this code to user specific needs:\n\nPut a max waiting time for the ack to arrive and resend the package or mark it as invalid\nIncrease the package size changing the _LORA_PKG_FORMAT to BH%ds. The H will allow the keeping of 2 bytes for size (for more information about struct format)\nReduce the package size with bitwise manipulation\nReduce the message size (for this demo, a string) to something more useful for specific development\n\n\n"},"tutorials/lora/module-module.html":{"url":"tutorials/lora/module-module.html","title":"LoPy to LoPy","keywords":"","body":"LoPy to LoPy\nThis example shows how to connect two Pycode LoRa capable modules (nodes) via raw LoRa.\nNode A\nfrom network import LoRa\nimport socket\nimport time\n\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORA, region=LoRa.EU868)\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\ns.setblocking(False)\n\nwhile True:\n if s.recv(64) == b'Ping':\n s.send('Pong')\n time.sleep(5)\n\nNode B\nfrom network import LoRa\nimport socket\nimport time\n\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORA, region=LoRa.EU868)\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\ns.setblocking(False)\nwhile True:\n s.send('Ping')\n time.sleep(5)\n\n"},"tutorials/lora/rn2483-to-lopy.html":{"url":"tutorials/lora/rn2483-to-lopy.html","title":"RN2483 to LoPy","keywords":"","body":"RN2483 to LoPy\nThis example shows how to send data between a Microchip RN2483 and a LoPy via raw LoRa.\nRN2483\nmac pause\nradio set freq 868000000\n\nradio set mod lora\nradio set bw 250\nradio set sf sf7\nradio set cr 4/5\nradio set bw 125\nradio set sync 12\nradio set prlen 8\n\n# Transmit via radio tx:\nradio tx 48656c6C6F #(should send ‘Hello')\n\nLoPy\nfrom network import LoRa\nimport socket\n\nlora = LoRa(mode=LoRa.LORA, frequency= 868000000, bandwidth=LoRa.BW_125KHZ, sf=7, preamble=8,\n coding_rate=LoRa.CODING_4_5, power_mode=LoRa.ALWAYS_ON,\n tx_iq=False, rx_iq=False, public=False)\n\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\n# This keeps listening for data \"forever\".\nwhile(True):\n s.recv(64)\n\n"},"tutorials/sigfox.html":{"url":"tutorials/sigfox.html","title":"Sigfox Examples","keywords":"","body":"Sigfox Examples\nBefore you start, make sure that your device was registered with Sigfox.\nThe following tutorials demonstrate how to register and get started with the SiPy. The board can be configured for operation in various countries based upon specified RCZ zones (see the Sigfox class for more info). The SiPy, LoPy 4, and FiPy supports both uplink and downlink Sigfox messages as well as device to device communication via its FSK Mode Sigfox.\nfrom network import Sigfox\nimport socket\n​\n# init Sigfox for RCZ1 (Europe)\nsigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)\n​\n# create a Sigfox socket\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\n​\n# make the socket blocking\ns.setblocking(True)\n​\n# configure it as uplink only\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False)\n​\n# send some bytes\ns.send(bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]))\n\nPlease ensure that there is an antenna connected to your device before sending/receiving Sigfox messages as in proper use (e.g. without an antenna), may damage the device.\n\nDisengage Sequence Number\nIf your are experiencing issues with Sigfox connectivity, this could be due to the sequence number being out of sync. To prevent replay on the network, the Sigfox protocol uses sequence numbers. If there is a large difference between the sequence number sent by the device and the one expected by the backend, your message is dropped by the network.\nYou can use the Disengage sequence number button on the device information or on the device type information page of the Sigfox backend to reset the number expected by the backend. If the sequence number of your next message is different from the last trashed sequence number, the message will be accepted.\nIssues with the sequence number can occur when a lot of messages are sent when outside of Sigfox coverage for instance.\nFirstly you will need to log into the Sigfox Backend, navigate to device, and click on the Sigfox ID of the affected SiPy.\n\nYou should now see the Information page with an entry Device Type: followed by a link. Please follow the link\n\nFinally, on this page click on Disengage sequence number button in the upper right corner.\n\n"},"tutorials/lte/":{"url":"tutorials/lte/","title":"LTE Examples","keywords":"","body":"LTE Examples\nThe following tutorials demonstrate the use of the LTE CAT-M1 and NB-IoT functionality on cellular enabled Pycom modules.\nOur cellular modules support both LTE CAT-M1 and NB-IoT, these are new lower power, long range, cellular protocols. These are not the same as the full version of 2G/3G/LTE supported by cell phones, and require your local carriers to support them. At the time of writing, CAT-M1 and NB-IoT connectivity is not widely available so be sure to check with local carriers if support is available where you are.\n"},"tutorials/lte/cat-m1.html":{"url":"tutorials/lte/cat-m1.html","title":"CAT-M1","keywords":"","body":"CAT-M1\nPlease ensure you have the latest Sequans modem firmware for the best network compatibility. Instructions for this can be found here.\n\nThe LTE Cat M1 service gives full IP access through the cellular modem.\nOnce the lte.connect() function has completed all the IP socket functions - including SSL - will be routed through this connection. This mean any code using WLAN can be adapted to Cat M1 by simply adding the connection setup step first and disconnect after.\nFor example to connect over LTE Cat M1 to Google's web server over secure SSL:\nimport socket\nimport ssl\nimport time\nfrom network import LTE\n\nlte = LTE() # instantiate the LTE object\nlte.attach() # attach the cellular modem to a base station\nwhile not lte.isattached():\n time.sleep(0.25)\nlte.connect() # start a data session and obtain an IP address\nwhile not lte.isconnected():\n time.sleep(0.25)\n\ns = socket.socket()\ns = ssl.wrap_socket(s)\ns.connect(socket.getaddrinfo('www.google.com', 443)[0][-1])\ns.send(b\"GET / HTTP/1.0\\r\\n\\r\\n\")\nprint(s.recv(4096))\ns.close()\n\nlte.disconnect()\nlte.dettach()\n\nThis also applies to our MQTT and AWS examples.\nIMPORTANT: Once the LTE radio is initialised, it must be de-initialised before going to deepsleep in order to ensure minimum power consumption. This is required due to the LTE radio being powered independently and allowing use cases which require the system to be taken out from deepsleep by an event from the LTE network (data or SMS received for instance).\nWhen using the expansion board and the FiPy together, the RTS/CTS jumpers MUST be removed as those pins are being used by the LTE radio. Keeping those jumpers in place will lead to erratic operation and higher current consumption specially while in deepsleep.\n"},"tutorials/lte/nb-iot.html":{"url":"tutorials/lte/nb-iot.html","title":"NB-IoT","keywords":"","body":"NB-IoT\nLTE class for Narrow Band IoT\nAs shipped, Pycom modules only support CAT-M1, in order to use NB-IoT you need to flash a different firmware to the Sequans modem. Instructions for this can be found here.\n\nNB-IoT usage\nExample with Vodafone:\nfrom network import LTE\n\nlte = LTE()\nlte.send_at_cmd('AT+CFUN=0')\nlte.send_at_cmd('AT!=\"clearscanconfig\"')\nlte.send_at_cmd('AT!=\"addscanband band=20\"')\nlte.send_at_cmd('AT!=\"disablelog 1\"')\nlte.send_at_cmd('AT+CGDCONT=1,\"IP\",\"nb.inetd.gdsp\"')\nlte.send_at_cmd('AT+CFUN=1')\n\nwhile not lte.isattached():\n pass\n\nlte.connect()\nwhile not lte.isconnected():\n pass\n\n# now use socket as usual...\n\nIMPORTANT: Once the LTE radio is initialised, it must be de-initialised before going to deepsleep in order to ensure minimum power consumption. This is required due to the LTE radio being powered independently and allowing use cases which require the system to be taken out from deepsleep by an event from the LTE network (data or SMS received for instance).\nWhen using the expansion board and the FiPy together, the RTS/CTS jumpers MUST be removed as those pins are being used by the LTE radio. Keeping those jumpers in place will lead to erratic operation and higher current consumption specially while in deepsleep.\n"},"tutorials/lte/imei.html":{"url":"tutorials/lte/imei.html","title":"Module IMEI","keywords":"","body":"Module IMEI\nIn order to retrieve the IMEI of your cellular enabled Pycom module you will firstly need to make sure you are on firmware version 1.17.0.b1 or higher. You can check your firmware version by running the following code on you device via the interactive REPL.\n>>> import os\n>>> os.uname()\n(sysname='GPy', nodename='GPy', release='1.17.0.b1', version='v1.8.6-849-d0dc708 on 2018-02-27', machine='GPy with ESP32')\n\nOnce you have a compatible firmware, you can run the following code to get your modules IMEI number:\nfrom network import LTE\nlte = LTE()\nlte.send_at_cmd('AT+CGSN=1')\n\nYou'll get a return string like this \\r\\n+CGSN: \"354347xxxxxxxxx\"\\r\\n\\r\\nOK. The value between the double quotes is your IMEI.\n"},"tutorials/lte/firmware.html":{"url":"tutorials/lte/firmware.html","title":"Modem Firmware Update","keywords":"","body":"Modem Firmware Update\nThis article is only related to GPy, FiPy, and G01 boards\n\nImportant: When upgrading your modem for the first time, even if you have updated it in the past with the old firmware update method, you MUST use the \"recovery\" upgrade method described below. Otherwise you will risk breaking your module\n\nPlease read the following instructions carefully as there are some significant changes compared to the previous updater version.\nMost importantly, the updater is now integrated in the latest stable firmware release (we will also publish a new development and pybytes firmware in the coming days), so you no longer need to upload any scripts to your module. The built-in updater will take precedence over any scripts uploaded.\nPlease start with the following steps:\n\nUpgrade the Pycom Firmware Updater tool to latest version\nSelect Firmware Type stable in the communication window to upgrade to version v1.18.1.r1\n\nYou can find the different versions of firmwares available here: https://software.pycom.io/downloads/sequans2.html\nWe are using CATM1-38638.zip and NB1-37781.zip as examples in this tutorial.\nAfter unpacking the zip archive, you will find each firmware packages contains two files, one being the firmware file (e.g. CATM1-38638.dup or NB1-37781.dup) and the updater.elf file, which is required when using the \"recovery\" firmware update method or if a previous upgrade failed and the modem is in recovery mode.\nPlease note that the updater.elf file is only around 300K so you can also store it inside the flash file system of the module. The firmware dup files will NOT fit into the available /flash file system on the module, so you either need to use an SD card or upload it directly from your computer.\nVia SD card\nTo transfer the firmware files onto the SD card you have two options:\n\nFormat your SD card as with the FAT file system and then copy the files onto the card using your computer\nMake sure your SD card has an MBR and a single primary partition, the format it directly on the module, mount it and transfer the firmware files onto the SD card using FTP. Please ensure the transfer is successful and that each file on the module has the same size as the original file on your PC.\n\nfrom machine import SD\n\nsd = SD()\nos.mkfs(sd) # format SD card\nos.mount(sd, '/sd') # mount it\nos.listdir('/sd') # list its content\n\nOnce you copied/uploaded the firmware files on to the SD card you can flash the LTE modem using the following command:\nTo flash the CAT-M1 firmware onto your device using the recovery method:\nimport sqnsupgrade\nsqnsupgrade.run('/sd/CATM1-38638.dup', '/sd/updater.elf')\n\nTo flash the NB-IoT firmware onto your device using the recovery method:\nimport sqnsupgrade\nsqnsupgrade.run('/sd/NB1-37781.dup', '/sd/updater.elf')\n\nPlease note you can directly flash the desired firmware onto your module, it is not necessary to upgrade to the latest CAT-M1 firmware before switching to NB-IoT.\nIf you have already mounted the SD card, please use the path you used when mounting it. Otherwise, if an absolute path other than /flash is specified, the script will automatically mount the SD card using the path specified.\nOnce update is finished successfully you will have a summary of new updated versions. The full output from the upgrade will looks similar to this:\n>>\nAttempting AT wakeup...\nStarting STP (DO NOT DISCONNECT POWER!!!)\nSession opened: version 1, max transfer 8192 bytes\nSending 54854 bytes: [########################################] 100%\nBootrom updated successfully, switching to upgrade mode\nAttempting AT auto-negotiation...\nSession opened: version 1, max transfer 2048 bytes\nSending 306076 bytes: [########################################] 100%\nAttempting AT wakeup...\nUpgrader loaded successfully, modem is in upgrade mode\nAttempting AT wakeup...\nStarting STP ON_THE_FLY\nSession opened: version 1, max transfer 8192 bytes\nSending 5996938 bytes: [########################################] 100%\nCode download done, returning to user mode\nResetting (DO NOT DISCONNECT POWER!!!)................\nUpgrade completed!\nHere's the current firmware version:\n\nSYSTEM VERSION\n==============\n FIRMWARE VERSION\n Bootloader0 : 5.1.1.0 [33080]\n Bootloader1 : 5.1.1.0 [38638]\n Bootloader2* : 5.1.1.0 [38638]\n NV Info : 1.1,0,0\n Software : 5.1.1.0 [38638] by robot-soft at 2018-08-20 09:51:46\n UE : 5.0.0.0d\n COMPONENTS\n ZSP0 : 1.0.99-13604\n ZSP1 : 1.0.99-12341\n\nPlease note that the firmware update may seem to \"stall\" around 7-10% and again at 99%. This is not an indication of a failure but the fact that the modem has to do some tasks during and the updater will wait for these tasks to be completed. Unless the upgrade process is hanging for more than 5 minutes, do not interrupt the process as you will have to start again if you don't finish it. It may also take several minutes for the updater to load before responding to the AT wakeup command.\n\nAfter you have updated your modem once using the recovery method, you can now flash your modem again using just the CATM1-38638.dup or NB1-37781.dup file without specifying the updater.elf file. However, should the upgrade fail, your modem may end up in recovery mode and you will need the updater.elf file again. The updater will check for this and prompt you if using the updater.elf file is necessary.\nExample output using just the firmware file:\n>>\nAttempting AT wakeup...\n\nStarting STP ON_THE_FLY\nSession opened: version 1, max transfer 8192 bytes\nSending 5996938 bytes: [########################################] 100%\nCode download done, returning to user mode\nResetting (DO NOT DISCONNECT POWER!!!)............................................................................\nUpgrade completed!\nHere's the current firmware version:\n\nSYSTEM VERSION\n==============\n FIRMWARE VERSION\n Bootloader0 : 5.1.1.0 [33080]\n Bootloader1* : 5.1.1.0 [38638]\n Bootloader2 : 5.1.1.0 [38638]\n NV Info : 1.1,0,0\n Software : 5.1.1.0 [38638] by robot-soft at 2018-08-20 09:51:46\n UE : 5.0.0.0d\n COMPONENTS\n ZSP0 : 1.0.99-13604\n ZSP1 : 1.0.99-12341\n\nVia UART Serial Interface\nIf you can't use an SD card to hold the firmware images, you can use the existing UART interface you have with the board to load these firmware files from your Computer.\nYou will need the following software installed on your computer:\n\nPython 3, if it's not directly available through your OS distributor\nPySerial\n\nYou will also need to download the following Python scripts: https://github.com/pycom/pycom-libraries/tree/master/lib/sqnsupgrade\nImportant: When upgrading your modem for the first time, even if you have updated it in the past with the old firmware update method, you MUST use the \"recovery\" upgrade method described below. Otherwise, you will risk breaking your module.\nYou can upload the updater.elf file to the module's flash file system rather than uploading it via UART directly to the modem, which will slightly increase the speed of the upgrade.\nFirst, you need to prepare your modem for upgrade mode by using the following commands.\nCommands to run on the Pycom module\nTo use the recovery method:\nimport sqnsupgrade\nsqnsupgrade.uart(True)\n\nTo use the recovery method using the updater.elf file on the module:\n import sqnsupgrade\n sqnsupgrade.uart(True,'/flash/updater.elf')\n\nTo use the normal method:\n import sqnsupgrade\n sqnsupgrade.uart()\n\nAfter this command is executed a message will be displayed asking you to close the port.\nGoing into MIRROR mode... please close this terminal to resume the upgrade via UART\n\nCommands to be run on your computer\nYou must close the terminal/Atom or Visual Studio Code console to run the following commands from your computer:\nGo to the directory where you saved the sqnsupgrade scripts and run the following commands in terminal:\nWhen using the recovery method:\n$ python3\nPython 3.6.5 (default, Apr 25 2018, 14:23:58)\n[GCC 4.2.1 Compatible Apple LLVM 9.1.0 (clang-902.0.39.1)] on darwin\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>>\n>>> import sqnsupgrade\n>>> sqnsupgrade.run('Serial_Port', '/path/to/CATM1-38638.dup', '/path/to/updater.elf')\n\nWhen using the standard method (or if the updater.elf was loaded on the module):\n $ python3\n Python 3.6.5 (default, Apr 25 2018, 14:23:58)\n [GCC 4.2.1 Compatible Apple LLVM 9.1.0 (clang-902.0.39.1)] on darwin\n Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n >>>\n >>> import sqnsupgrade\n >>> sqnsupgrade.run('Serial_Port', '/path/to/CATM1-38638.dup')\n\nPlease note that the firmware update may seem to \"stall\" around 7-10% and again at 99%. This is not an indication of a failure but the fact that the modem has to do some tasks during and the updater will wait for these tasks to be completed. Unless the upgrade process is hanging for more than 5 minutes, do not interrupt the process as you will have to start again if you don't finish it. It may also take several minutes for the updater to load before responding to the AT wakeup command.\nRetrying process\nIn case of any failure or interruption to the process of LTE modem upgrade you can repeat the same steps after doing a hard reset to the board (i.e disconnecting and reconnecting power), pressing the reset button is not enough.\n"},"tutorials/pytrack.html":{"url":"tutorials/pytrack.html","title":"Pytrack Examples","keywords":"","body":"Pytrack Examples\nBoth the Pysense and Pytrack use the same accelerometer. Please see the Pysense Examples to see how to use the accelerometer.\nExample\nYou can find this example in the pycom/pycom-libraries GitHub repository.\nimport machine\nimport math\nimport network\nimport os\nimport time\nimport utime\nimport gc\nfrom machine import RTC\nfrom machine import SD\nfrom L76GNSS import L76GNSS\nfrom pytrack import Pytrack\n\ntime.sleep(2)\ngc.enable()\n\n# setup rtc\nrtc = machine.RTC()\nrtc.ntp_sync(\"pool.ntp.org\")\nutime.sleep_ms(750)\nprint('\\nRTC Set from NTP to UTC:', rtc.now())\nutime.timezone(7200)\nprint('Adjusted from UTC to EST timezone', utime.localtime(), '\\n')\n\npy = Pytrack()\nl76 = L76GNSS(py, timeout=30)\n\n# sd = SD()\n# os.mount(sd, '/sd')\n# f = open('/sd/gps-record.txt', 'w')\n\nwhile (True):\n coord = l76.coordinates()\n #f.write(\"{} - {}\\n\".format(coord, rtc.now()))\n print(\"{} - {} - {}\".format(coord, rtc.now(), gc.mem_free()))\n\nAlternative Libraries\n\nmicropyGPS\nAlternative L76GNSS module\n\n"},"tutorials/pysense.html":{"url":"tutorials/pysense.html","title":"Pysense Examples","keywords":"","body":"Pysense Examples\nAccelerometer\nThis basic example shows how to read pitch and roll from the on-board accelerometer and output it in comma separated value (CSV) format over serial.\nfrom LIS2HH12 import LIS2HH12\nfrom pytrack import Pytrack\npy = Pytrack()\nacc = LIS2HH12()\n\nwhile True:\n pitch = acc.pitch()\n roll = acc.roll()\n print('{},{}'.format(pitch, roll))\n time.sleep_ms(100)\n\n\nIf you want to visualise the data output by this script a Processing sketch is available here that will show the board orientation in 3D.\n"},"tutorials/pyscan.html":{"url":"tutorials/pyscan.html","title":"Pyscan Examples","keywords":"","body":"Pyscan Examples\nThis basic example shows how to read an NFC card and authenticate it using a pre-defined access list.\nfrom pyscan import Pyscan\nfrom MFRC630 import MFRC630\nimport time\nimport pycom\nimport _thread\n\nVALID_CARDS = [[0x43, 0x95, 0xDD, 0xF8],\n [0x43, 0x95, 0xDD, 0xF9]]\n\npy = Pyscan()\nnfc = MFRC630(py)\n\nRGB_BRIGHTNESS = 0x8\n\nRGB_RED = (RGB_BRIGHTNESS 0):\n if (check_uid(list(uid), uid_len)) > 0:\n pycom.rgbled(RGB_GREEN)\n else:\n pycom.rgbled(RGB_RED)\n else:\n # No card detected\n pycom.rgbled(RGB_BLUE)\n nfc.mfrc630_cmd_reset()\n time.sleep(.5)\n nfc.mfrc630_cmd_init()\n\n# This is the start of our main execution... start the thread\n_thread.start_new_thread(discovery_loop, (nfc, 0))\n\nYou can find this, and all the other examples in our pycom-libraries GitHub repository\n"},"firmwareapi/introduction.html":{"url":"firmwareapi/introduction.html","title":"Introduction","keywords":"","body":"Introduction\nThis chapter describes modules (function and class libraries) that are built into MicroPython. There are a number of categories for the available modules:\n\nModules which implement a subset of standard Python functionality and are not intended to be extended by the user.\nModules which implement a subset of Python functionality, with a provision for extension by the user (via Python code).\nModules which implement MicroPython extensions to the Python standard libraries.\nModules specific to a particular port and thus not portable.\n\nNote about the availability of modules and their contents\nThis documentation in general aspires to describe all modules and functions/classes which are implemented in MicroPython. However, MicroPython is highly configurable, and each port to a particular board/embedded system makes available only a subset of MicroPython libraries. For officially supported ports, there is an effort to either filter out non-applicable items, or mark individual descriptions with “Availability:” clauses describing which ports provide a given feature. With that in mind, please still be warned that some functions/classes in a module (or even the entire module) described in this documentation may be unavailable in a particular build of MicroPython on a particular board. The best place to find general information of the availability/non-availability of a particular feature is the “General Information” section which contains information pertaining to a specific port.\nBeyond the built-in libraries described in this documentation, many more modules from the Python standard library, as well as further MicroPython extensions to it, can be found in the micropython-lib repository.\n"},"firmwareapi/pycom/":{"url":"firmwareapi/pycom/","title":"Pycom Modules","keywords":"","body":"Pycom Modules\nThese modules are specific to the Pycom devices and may have slightly different implementations to other variations of MicroPython (i.e. for Non-Pycom devices). Modules include those which support access to underlying hardware, e.g. I2C, SPI, WLAN, Bluetooth, etc.\n"},"firmwareapi/pycom/machine/":{"url":"firmwareapi/pycom/machine/","title":"machine","keywords":"","body":"machine\nThe machine module contains specific functions related to the board.\nQuick Usage Example\nimport machine\n\nhelp(machine) # display all members from the machine module\nmachine.freq() # get the CPU frequency\nmachine.unique_id() # return the 6-byte unique id of the board (the LoPy's WiFi MAC address)\n\nReset Functions\nmachine.reset()\nResets the device in a manner similar to pushing the external RESET button.\nmachine.reset_cause()\nGet the reset cause. See constants for the possible return values.\nInterrupt Functions\nmachine.disable_irq()\nDisable interrupt requests. Returns and integer representing the previous IRQ state. This return value can be passed to enable_irq to restore the IRQ to its original state.\nmachine.enable_irq([state])\nEnable interrupt requests. The most common use of this function is to pass the value returned by disable_irq to exit a critical section. Another options is to enable all interrupts which can be achieved by calling the function with no parameters.\nPower Functions\nmachine.freq()\nReturns CPU frequency in hertz.\nmachine.idle()\nGates the clock to the CPU, useful to reduce power consumption at any time during short or long periods. Peripherals continue working and execution resumes as soon as any interrupt is triggered (on many ports this includes system timer interrupt occurring at regular intervals on the order of millisecond).\nmachine.deepsleep([time_ms])\nStops the CPU and all peripherals, including the networking interfaces (except for LTE). Execution is resumed from the main script, just as with a reset. If a value in milliseconds is given then the device will wake up after that period of time, otherwise it will remain in deep sleep until the reset button is pressed.\nThe products with LTE connectivity (FiPy, GPy, G01), require the LTE radio to be disabled separately via the LTE class before entering deepsleep. This is required due to the LTE radio being powered independently and allowing use cases which require the system to be taken out from deepsleep by an event from the LTE network (data or SMS received for instance).\nmachine.pin_deepsleep_wakeup(pins, mode, enable_pull)\nConfigure pins to wake up from deep sleep mode. The pins which have this capability are: P2, P3, P4, P6, P8 to P10 and P13 to P23.\nThe arguments are:\n\npins a list or tuple containing the GPIO to setup for deepsleep wakeup.\nmode selects the way the configure GPIOs can wake up the module. The possible values are: machine.WAKEUP_ALL_LOW and machine.WAKEUP_ANY_HIGH.\nenable_pull if set to True keeps the pull up or pull down resistors enabled during deep sleep. If this variable is set to True, then ULP or capacitive touch wakeup cannot be used in combination with GPIO wakeup.\n\nmachine.wake_reason()\nGet the wake reason. See constants for the possible return values. Returns a tuple of the form: (wake_reason, gpio_list). When the wakeup reason is either GPIO or touch pad, then the second element of the tuple is a list with GPIOs that generated the wakeup.\nmachine.remaining_sleep_time()\nReturns the remaining timer duration (in milliseconds) if the ESP32 is woken up from deep sleep by something other than the timer. For example, if you set the timer for 30 seconds (30000 ms) and it wakes up after 10 seconds then this function will return 20000.\nMiscellaneous Functions\nmachine.main(filename)\nSet the filename of the main script to run after boot.py is finished. If this function is not called then the default file main.py will be executed.\nIt only makes sense to call this function from within boot.py.\nmachine.rng()\nReturn a 24-bit software generated random number.\nmachine.unique_id()\nReturns a byte string with a unique identifier of a board/SoC. It will vary from a board/SoC instance to another, if underlying hardware allows. Length varies by hardware (so use substring of a full value if you expect a short ID). In some MicroPython ports, ID corresponds to the network MAC address.\nUse ubinascii.hexlify() to convert the byte string to hexadecimal form for ease of manipulation and use elsewhere.\n\nmachine.info()\nReturns the high water mark of the stack associated with various system tasks, in words (1 word = 4 bytes on the ESP32). If the value is zero then the task has likely overflowed its stack. If the value is close to zero then the task has come close to overflowing its stack.\nConstants\nReset Causes\nmachine.PWRON_RESET, machine.HARD_RESET, machine.WDT_RESET, machine.DEEPSLEEP_RESET, machine.SOFT_RESET, machine.BROWN_OUT_RESET\nWake Reasons\nmachine.PWRON_WAKE, machine.PIN_WAKE, machine.RTC_WAKE, machine.ULP_WAKE\nPin Wakeup Modes\nmachine.WAKEUP_ALL_LOW, machine.WAKEUP_ANY_HIGH\n"},"firmwareapi/pycom/machine/adc.html":{"url":"firmwareapi/pycom/machine/adc.html","title":"ADC","keywords":"ADC Analog ADCChannel","body":"ADC\nclass ADC – Analog to Digital Conversion\nQuick Usage Example\nimport machine\n\nadc = machine.ADC() # create an ADC object\napin = adc.channel(pin='P16') # create an analog pin on P16\nval = apin() # read an analog value\n\nConstructors\nclass machine.ADC(id=0)\nCreate an ADC object; associate a channel with a pin. For more info check the hardware section.\nMethods\nadc.init( * , bits=12)\nEnable the ADC block. This method is automatically called on object creation.\n\nBits can take values between 9 and 12 and selects the number of bits of resolution of the ADC block.\n\nadc.deinit()\nDisable the ADC block.\nadc.channel(* , pin, attn=ADC.ATTN_0DB)\nCreate an analog pin.\n\npin is a keyword-only string argument. Valid pins are P13 to P20.\nattn is the attenuation level. The supported values are: ADC.ATTN_0DB, ADC.ATTN_2_5DB, ADC.ATTN_6DB, ADC.ATTN_11DB\n\nReturns an instance of ADCChannel. Example:\n# enable an ADC channel on P16\napin = adc.channel(pin='P16')\n\nadc.vref(vref)\nIf called without any arguments, this function returns the current calibrated voltage (in millivolts) of the 1.1v reference. Otherwise it will update the calibrated value (in millivolts) of the internal 1.1v reference.\nadc.vref_to_pin(pin)\nConnects the internal 1.1v to external GPIO. It can only be connected to P22, P21 or P6. It is recommended to only use P6 on the WiPy, on other modules this pin is connected to the radio.\nConstants\n\nADC channel attenuation values: ADC.ATTN_0DB, ADC.ATTN_2_5DB, ADC.ATTN_6DB, ADC.ATTN_11DB\n\nclass ADCChannel\nRead analog values from internal/external sources. ADC channels can be connected to internal points of the MCU or to GPIO pins. ADC channels are created using the ADC.channel method.\nMethods\nadcchannel()\nFast method to read the channel value.\nadcchannel.value()\nRead the channel value.\nadcchannel.init()\n(Re)init and enable the ADC channel. This method is automatically called on object creation.\nadcchannel.deinit()\nDisable the ADC channel.\nadcchannel.voltage()\nReads the channels value and converts it into a voltage (in millivolts)\nadcchannel.value_to_voltage(value)\nConverts the provided value into a voltage (in millivolts) in the same way voltage does.\nADC pin input range is 0-1.1V. This maximum value can be increased up to 3.3V using the highest attenuation of 11dB. Do not exceed the maximum of 3.3V, to avoid damaging the device.\n\n"},"firmwareapi/pycom/machine/dac.html":{"url":"firmwareapi/pycom/machine/dac.html","title":"DAC","keywords":"","body":"DAC\nThe DAC is used to output analog values (a specific voltage) on pin P22 or pin P21. The voltage will be between 0 and 3.3V.\nQuick Usage Example\nimport machine\n\ndac = machine.DAC('P22') # create a DAC object\ndac.write(0.5) # set output to 50%\n\ndac_tone = machine.DAC('P21') # create a DAC object\ndac_tone.tone(1000, 0) # set tone output to 1kHz\n\nConstructors\nclass class machine.DAC(pin)\nCreate a DAC object, that will let you associate a channel with a pin. pin can be a string argument.\nMethods\ndac.init()\nEnable the DAC block. This method is automatically called on object creation.\ndac.deinit()\nDisable the DAC block.\ndac.write(value)\nSet the DC level for a DAC pin. value is a float argument, with values between 0 and 1.\ndac.tone(frequency, amplitude)\nSets up tone signal to the specified frequency at amplitude scale. frequency can be from 125Hz to 20kHz in steps of 122Hz. amplitude is an integer specifying the tone amplitude to write the DAC pin. Amplitude value represents:\n\n0 is 0dBV (~ 3Vpp at 600 Ohm load)\n1 is -6dBV (~1.5 Vpp), 2 is -12dBV (~0.8 Vpp)\n3 is -18dBV (~0.4 Vpp).\nThe generated signal is a sine wave with an DC offset of VDD/2.\n\n\n"},"firmwareapi/pycom/machine/i2c.html":{"url":"firmwareapi/pycom/machine/i2c.html","title":"I2C","keywords":"","body":"I2C\nI2C is a two-wire protocol for communicating between devices. At the physical level it consists of 2 wires: SCL and SDA, the clock and data lines respectively.\nI2C objects are created attached to a specific bus. They can be initialised when created, or initialised later on.\nExample using default Pins\nfrom machine import I2C\n\ni2c = I2C(0) # create on bus 0\ni2c = I2C(0, I2C.MASTER) # create and init as a master\ni2c = I2C(0, pins=('P10','P11')) # create and use non-default PIN assignments (P10=SDA, P11=SCL)\ni2c.init(I2C.MASTER, baudrate=20000) # init as a master\ni2c.deinit() # turn off the peripheral\n\nExample using non-default Pins\nfrom machine import I2C\n\ni2c = I2C(0, pins=('P10','P11')) # create and use non-default PIN assignments (P10=SDA, P11=SCL)\ni2c.init(I2C.MASTER, baudrate=20000) # init as a master\ni2c.deinit() # turn off the peripheral\n\nPrinting the i2c object gives you information about its configuration.\nA master must specify the recipient's address:\ni2c.init(I2C.MASTER)\ni2c.writeto(0x42, '123') # send 3 bytes to slave with address 0x42\ni2c.writeto(addr=0x42, b'456') # keyword for address\n\nMaster also has other methods:\ni2c.scan() # scan for slaves on the bus, returning\n # a list of valid addresses\ni2c.readfrom_mem(0x42, 2, 3) # read 3 bytes from memory of slave 0x42,\n # starting at address 2 in the slave\ni2c.writeto_mem(0x42, 2, 'abc') # write 'abc' (3 bytes) to memory of slave 0x42\n # starting at address 2 in the slave, timeout after 1 second\n\nQuick Usage Example\nfrom machine import I2C\n# configure the I2C bus\ni2c = I2C(0, I2C.MASTER, baudrate=100000)\ni2c.scan() # returns list of slave addresses\ni2c.writeto(0x42, 'hello') # send 5 bytes to slave with address 0x42\ni2c.readfrom(0x42, 5) # receive 5 bytes from slave\ni2c.readfrom_mem(0x42, 0x10, 2) # read 2 bytes from slave 0x42, slave memory 0x10\ni2c.writeto_mem(0x42, 0x10, 'xy') # write 2 bytes to slave 0x42, slave memory 0x10\n\nConstructors\nclass machine.I2C(bus, ...)\nConstruct an I2C object on the given bus. bus can only be 0, 1, 2. If the bus is not given, the default one will be selected (0). Buses 0 and 1 use the ESP32 I2C hardware peripheral while bus 2 is implemented with a bit-banged software driver.\nMethods\nGeneral Methods\ni2c.init(mode, * , baudrate=100000, pins=(SDA, SCL))\nInitialise the I2C bus with the given parameters:\n\nmode must be I2C.MASTER\nbaudrate is the SCL clock rate\npins is an optional tuple with the pins to assign to the I2C bus. The default I2C pins are P9 (SDA) and P10 (SCL)\n\ni2c.scan()\nScan all I2C addresses between 0x08 and 0x77 inclusive and return a list of those that respond. A device responds if it pulls the SDA line low after its address (including a read bit) is sent on the bus.\nStandard Bus Operations\nThe following methods implement the standard I2C master read and write operations that target a given slave device.\ni2c.readfrom(addr, nbytes)\nRead nbytes from the slave specified by addr. Returns a bytes object with the data read.\ni2c.readfrom_into(addr, buf)\nRead into buf from the slave specified by addr. The number of bytes read will be the length of buf.\nReturn value is the number of bytes read.\ni2c.writeto(addr, buf, * , stop=True)\nWrite the bytes from buf to the slave specified by addr. The argument buf can also be an integer which will be treated as a single byte. If stop is set to False then the stop condition won't be sent and the I2C operation may be continued (typically with a read transaction).\nReturn value is the number of bytes written.\nMemory Operations\nSome I2C devices act as a memory device (or set of registers) that can be read from and written to. In this case there are two addresses associated with an I2C transaction: the slave address and the memory address. The following methods are convenience functions to communicate with such devices.\ni2c.readfrom_mem(addr, memaddr, nbytes, *, addrsize=8)\nRead nbytes from the slave specified by addr starting from the memory address specified by memaddr. The addrsize argument is specified in bits and it can only take 8 or 16.\ni2c.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8)\nRead into buf from the slave specified by addr starting from the memory address specified by memaddr. The number of bytes read is the length of buf. The addrsize argument is specified in bits and it can only take 8 or 16.\nThe return value is the number of bytes read.\ni2c.writeto_mem(addr, memaddr, buf *, addrsize=8)\nWrite buf to the slave specified by addr starting from the memory address specified by memaddr. The argument buf can also be an integer which will be treated as a single byte. The addrsize argument is specified in bits and it can only take 8 or 16.\nThe return value is the number of bytes written.\nConstants\n\nI2C.MASTER: Used to initialise the bus to master mode.\n\n"},"firmwareapi/pycom/machine/pin.html":{"url":"firmwareapi/pycom/machine/pin.html","title":"Pin","keywords":"","body":"Pin\nA pin is the basic object to control I/O pins (also known as GPIO - general-purpose input/output). It has methods to set the mode of the pin (input, output, etc) and methods to get and set the digital logic level. For analog control of a pin, see the ADC class.\nQuick Usage Example\nfrom machine import Pin\n\n# initialize `P9` in gpio mode and make it an output\np_out = Pin('P9', mode=Pin.OUT)\np_out.value(1)\np_out.value(0)\np_out.toggle()\np_out(True)\n\n# make `P10` an input with the pull-up enabled\np_in = Pin('P10', mode=Pin.IN, pull=Pin.PULL_UP)\np_in() # get value, 0 or 1\n\nConstructors\nclass machine.Pin(id, ...)\nCreate a new Pin object associated with the string id. If additional arguments are given, they are used to initialise the pin. See pin.init()\nfrom machine import Pin\np = Pin('P10', mode=Pin.OUT, pull=None, alt=-1)\n\nMethods\npin.init(mode, pull, * , alt)\nInitialise the pin:\n\nmode can be one of:\nPin.IN - input pin.\nPin.OUT - output pin in push-pull mode.\nPin.OPEN_DRAIN - input or output pin in open-drain mode.\n\n\npull can be one of:\nNone - no pull up or down resistor.\nPin.PULL_UP - pull up resistor enabled.\nPin.PULL_DOWN - pull down resistor enabled.\n\n\n*\nPin value: 0 or 1\n\n\nalt is the id of the alternate function.\n\nReturns: None.\npin.id()\nGet the pin id.\npin.value([value])\nGet or set the digital logic level of the pin:\n\nWith no argument, return 0 or 1 depending on the logic level of the pin.\nWith value given, set the logic level of the pin. value can be anything that converts to a boolean. If it converts to True, the pin is set high, otherwise it is set low.\n\npin([value])\nPin objects are callable. The call method provides a (fast) shortcut to set and get the value of the pin.\nExample:\nfrom machine import Pin\npin = Pin('P12', mode=Pin.IN, pull=Pin.PULL_UP)\npin() # fast method to get the value\n\nSee pin.value() for more details.\npin.toggle()\nToggle the value of the pin.\npin.mode([mode])\nGet or set the pin mode.\npin.pull([pull])\nGet or set the pin pull.\npin.hold([hold])\nGet or set the pin hold. You can apply a hold to a pin by passing True (or clear it by passing False). When a pin is held, its value cannot be changed by using Pin.value() or Pin.toggle() until the hold is released. This Can be used to retain the pin state through a core reset and system reset triggered by watchdog time-out or Deep-sleep events. Only pins in the RTC power domain can retain their value through deep sleep or reset.\nThese are: P2, P3, P4, P6, P8, P9, P10, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23\npin.callback(trigger, handler=None, arg=None)\nSet a callback to be triggered when the input level at the pin changes.\n\ntrigger is the type of event that triggers the callback. Possible values are:\nPin.IRQ_FALLING interrupt on falling edge.\nPin.IRQ_RISING interrupt on rising edge.\nPin.IRQ_LOW_LEVEL interrupt on low level.\nPin.IRQ_HIGH_LEVEL interrupt on high level.\n\n\n\nThe values can be OR-ed together, for instance trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING\n\nhandler is the function to be called when the event happens. This function will receive one argument. Set handler to None to disable it.\narg is an optional argument to pass to the callback. If left empty or set to None, the function will receive the Pin object that triggered it.\n\nExample:\nfrom machine import Pin\n\ndef pin_handler(arg):\n print(\"got an interrupt in pin %s\" % (arg.id()))\n\np_in = Pin('P10', mode=Pin.IN, pull=Pin.PULL_UP)\np_in.callback(Pin.IRQ_FALLING | Pin.IRQ_RISING, pin_handler)\n\nFor more information on how Pycom's products handle interrupts, see here.\n\nAttributes\nclass pin.exp_board\nContains all Pin objects supported by the expansion board. Examples:\nPin.exp_board.G16\nled = Pin(Pin.exp_board.G16, mode=Pin.OUT)\nPin.exp_board.G16.id()\n\nclass pin.module\nContains all Pin objects supported by the module. Examples:\nPin.module.P9\nled = Pin(Pin.module.P9, mode=Pin.OUT)\nPin.module.P9.id()\n\nConstants\nThe following constants are used to configure the pin objects. Note that not all constants are available on all ports.\n\nSelects the pin mode: Pin.IN, Pin.OUT, Pin.OPEN_DRAIN\nEnables the pull up or pull down resistor: Pin.PULL_UP, Pin.PULL_DOWN\n\n"},"firmwareapi/pycom/machine/pwm.html":{"url":"firmwareapi/pycom/machine/pwm.html","title":"PWM","keywords":"","body":"PWM\nclass PWM – Pulse Width Modulation\nQuick Usage Example\nfrom machine import PWM\npwm = PWM(0, frequency=5000) # use PWM timer 0, with a frequency of 5KHz\n# create pwm channel on pin P12 with a duty cycle of 50%\npwm_c = pwm.channel(0, pin='P12', duty_cycle=0.5)\npwm_c.duty_cycle(0.3) # change the duty cycle to 30%\n\nConstructors\nclass machine.PWM(timer, frequency)\nCreate a PWM object. This sets up the timer to oscillate at the specified frequency. timer is an integer from 0 to 3. frequency is an integer from 1 Hz to 78 KHz (this values can change in future upgrades).\nMethods\npwm.channel(id, pin * , duty_cycle=0.5)\nConnect a PWM channel to a pin, setting the initial duty cycle. id is an integer from 0 to 7. pin is a string argument. duty_cycle is a keyword-only float argument, with values between 0 and 1. Returns an instance of PWMChannel.\nclass PWMChannel — PWM channel\nMethods\npwmchannel.duty_cycle(value)\nSet the duty cycle for a PWM channel. value is a float argument, with values between 0 and 1.\n"},"firmwareapi/pycom/machine/rtc.html":{"url":"firmwareapi/pycom/machine/rtc.html","title":"RTC","keywords":"","body":"RTC\nThe RTC is used to keep track of the date and time.\nQuick Usage Example\nfrom machine import RTC\n\nrtc = RTC()\nrtc.init((2014, 5, 1, 4, 13, 0, 0, 0))\nprint(rtc.now())\n\nConstructors\nclass machine.RTC(id=0, ...)\nCreate an RTC object. See init for parameters of initialisation.\n# id of the RTC may be set if multiple are connected. Defaults to id = 0.\nrtc = RTC(id=0)\n\nMethods\nrtc.init(datetime=None, source=RTC.INTERNAL_RC)\nInitialise the RTC. The arguments are:\n\ndatetime when passed it sets the current time. It is a tuple of the form: (year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])\nsource selects the oscillator that drives the RTC. The options are RTC.INTERNAL_RC and RTC.XTAL_32KHZ\n\nFor example:\n# for 2nd of February 2017 at 10:30am (TZ 0)\nrtc.init((2017, 2, 28, 10, 30, 0, 0, 0))\n\ntzinfo is ignored by this method. Use time.timezone to achieve similar results.\n\nrtc.now()\nGet get the current datetime tuple:\n# returns datetime tuple\nrtc.now()\n\nrtc.ntp_sync(server, * , update_period=3600)\nSet up automatic fetch and update the time using NTP (SNTP).\n\nserver is the URL of the NTP server. Can be set to None to disable the periodic updates.\nupdate_period is the number of seconds between updates. Shortest period is 15 seconds.\n\nCan be used like:\nrtc.ntp_sync(\"pool.ntp.org\") # this is an example. You can select a more specific server according to your geographical location\n\nrtc.synced()\nReturns True if the last ntp_sync has been completed, False otherwise:\nrtc.synced()\n\nConstants\n\nClock source: RTC.INTERNAL_RC, RTC.XTAL_32KHZ\n\n"},"firmwareapi/pycom/machine/spi.html":{"url":"firmwareapi/pycom/machine/spi.html","title":"SPI","keywords":"","body":"SPI\nSPI is a serial protocol that is driven by a master. At the physical level there are 3 lines: SCK, MOSI, MISO.\nSee usage model of I2C; SPI is very similar. Main difference is parameters to init the SPI bus:\nfrom machine import SPI\nspi = SPI(0, mode=SPI.MASTER, baudrate=1000000, polarity=0, phase=0, firstbit=SPI.MSB)\n\nOnly required parameter is mode, must be SPI.MASTER. Polarity can be 0 or 1, and is the level the idle clock line sits at. Phase can be 0 or 1 to sample data on the first or second clock edge respectively.\nQuick Usage Example\nfrom machine import SPI\n\n# configure the SPI master @ 2MHz\n# this uses the SPI default pins for CLK, MOSI and MISO (``P10``, ``P11`` and ``P14``)\nspi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=0, phase=0)\nspi.write(bytes([0x01, 0x02, 0x03, 0x04, 0x05])) # send 5 bytes on the bus\nspi.read(5) # receive 5 bytes on the bus\nrbuf = bytearray(5)\nspi.write_readinto(bytes([0x01, 0x02, 0x03, 0x04, 0x05]), rbuf) # send a receive 5 bytes\n\nQuick Usage Example using non-default pins\nfrom machine import SPI\n\n# configure the SPI master @ 2MHz\n# this uses the SPI non-default pins for CLK, MOSI and MISO (``P19``, ``P20`` and ``P21``)\nspi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=0, phase=0, pins=('P19','P20','P21'))\nspi.write(bytes([0x01, 0x02, 0x03, 0x04, 0x05])) # send 5 bytes on the bus\nspi.read(5) # receive 5 bytes on the bus\nrbuf = bytearray(5)\nspi.write_readinto(bytes([0x01, 0x02, 0x03, 0x04, 0x05]), rbuf) # send a receive 5 bytes\n\nConstructors\nclass machine.SPI(id, ...)\nConstruct an SPI object on the given bus. id can be only 0. With no additional parameters, the SPI object is created but not initialised (it has the settings from the last initialisation of the bus, if any). If extra arguments are given, the bus is initialised. See init for parameters of initialisation.\nMethods\nspi.init(mode, baudrate=1000000, * , polarity=0, phase=0, bits=8, firstbit=SPI.MSB, pins=(CLK, MOSI, MISO))\nInitialise the SPI bus with the given parameters:\n\nmode must be SPI.MASTER.\nbaudrate is the SCK clock rate.\npolarity can be 0 or 1, and is the level the idle clock line sits at.\nphase can be 0 or 1 to sample data on the first or second clock edge respectively.\nbits is the width of each transfer, accepted values are 8, 16 and 32.\nfirstbit can be SPI.MSB or SPI.LSB.\npins is an optional tuple with the pins to assign to the SPI bus. If the pins argument is not given the default pins will be selected (P10 as CLK,P11 as MOSI and P14 as MISO). If pins is passed as None then no pin assignment will be made.\n\nspi.deinit()\nTurn off the SPI bus.\nspi.write(buf)\nWrite the data contained in buf. Returns the number of bytes written.\nspi.read(nbytes, * , write=0x00)\nRead the nbytes while writing the data specified by write. Returns the bytes read.\nspi.readinto(buf, * , write=0x00)\nRead into the buffer specified by buf while writing the data specified by write. Return the number of bytes read.\nspi.write_readinto(write_buf, read_buf)\nWrite from write_buf and read into read_buf. Both buffers must have the same length. Returns the number of bytes written\nConstants\n\nFor initialising the SPI bus to master: SPI.MASTER\nSet the first bit to be the most significant bit: SPI.MSB\nSet the first bit to be the least significant bit: SPI.LSB\n\n"},"firmwareapi/pycom/machine/uart.html":{"url":"firmwareapi/pycom/machine/uart.html","title":"UART","keywords":"","body":"UART\nUART implements the standard UART/USART duplex serial communications protocol. At the physical level it consists of 2 lines: RXD and TXD. The unit of communication is a character (not to be confused with a string character) which can be 5, 6, 7 or 8 bits wide.\nUART objects can be created and initialised using:\nfrom machine import UART\n\nuart = UART(1, 9600) # init with given baudrate\nuart.init(9600, bits=8, parity=None, stop=1) # init with given parameters\n\nBits can be 5, 6, 7, 8. Parity can be None, UART.EVEN or UART.ODD. Stop can be 1, 1.5 or 2.\nA UART object acts like a stream object therefore reading and writing is done using the standard stream methods:\nuart.read(10) # read 10 characters, returns a bytes object\nuart.readall() # read all available characters\nuart.readline() # read a line\nuart.readinto(buf) # read and store into the given buffer\nuart.write('abc') # write the 3 characters\n\nTo check if there is anything to be read, use:\nuart.any() # returns the number of characters available for reading\n\nQuick Usage Example\nfrom machine import UART\n# this uses the UART_1 default pins for TXD and RXD (``P3`` and ``P4``)\nuart = UART(1, baudrate=9600)\nuart.write('hello')\nuart.read(5) # read up to 5 bytes\n\nQuick Usage Example using non-default pins (TXD/RXD only)\nfrom machine import UART\n# this uses the UART_1 non-default pins for TXD and RXD (``P20`` and ``P21``)\nuart = UART(1, baudrate=9600, pins=('P20','P21'))\nuart.write('hello')\nuart.read(5) # read up to 5 bytes\n\nQuick Usage Example using non-default pins (TXD/RXD and flow control)\nfrom machine import UART\n# this uses the UART_1 non-default pins for TXD, RXD, RTS and CTS (``P20``, ``P21``, ``P22``and ``P23``)\nuart = UART(1, baudrate=9600, pins=('P20', 'P21', 'P22', 'P23'))\nuart.write('hello')\nuart.read(5) # read up to 5 bytes\n\nConstructors\nclass machine.UART(bus, ...)\nConstruct a UART object on the given bus. bus can be 0, 1 or 2. If the bus is not given, the default one will be selected (0) or the selection will be made based on the given pins.\nOn the GPy/FiPy UART2 is unavailable because it is used to communicate with the cellular radio.\n\nMethods\nuart.init(baudrate=9600, bits=8, parity=None, stop=1, * , timeout_chars=2, pins=(TXD, RXD, RTS, CTS))\nInitialise the UART bus with the given parameters:\n\nbaudrate is the clock rate.\nbits is the number of bits per character. Can be 5, 6, 7 or 8.\nparity is the parity, None, UART.EVEN or UART.ODD.\nstop is the number of stop bits, 1 or 2.\ntimeout_chars Rx timeout defined in number of characters. The value given here will be multiplied by the time a characters takes to be transmitted at the configured baudrate.\npins is a 4 or 2 item list indicating the TXD, RXD, RTS and CTS pins (in that order). Any of the pins can be None if one wants the UART to operate with limited functionality. If the RTS pin is given the the RX pin must be given as well. The same applies to CTS. When no pins are given, then the default set of TXD (P1) and RXD (P0) pins is taken, and hardware flow control will be disabled. If pins=None, no pin assignment will be made.\n\nuart.deinit()\nTurn off the UART bus.\nuart.any()\nReturn the number of characters available for reading.\nuart.read([nbytes])\nRead characters. If nbytes is specified then read at most that many bytes.\nReturn value: a bytes object containing the bytes read in. Returns None on timeout.\nuart.readall()\nRead as much data as possible.\nReturn value: a bytes object or None on timeout.\nuart.readinto(buf[, nbytes])\nRead bytes into the buf. If nbytes is specified then read at most that many bytes. Otherwise, read at most len(buf) bytes.\nReturn value: number of bytes read and stored into buf or None on timeout.\nuart.readline()\nRead a line, ending in a newline character. If such a line exists, return is immediate. If the timeout elapses, all available data is returned regardless of whether a newline exists.\nReturn value: the line read or None on timeout if no data is available.\nuart.write(buf)\nWrite the buffer of bytes to the bus.\nReturn value: number of bytes written or None on timeout.\nuart.sendbreak()\nSend a break condition on the bus. This drives the bus low for a duration of 13 bits. Return value: None.\nuart.wait_tx_done(timeout_ms)\nWaits at most timeout_ms for the last Tx transaction to complete. Returns True if all data has been sent and the TX buffer has no data in it, otherwise returns False.\nConstants\n\nParity types (along with None): UART.EVEN, UART.ODD\nIRQ trigger sources: UART.RX_ANY\n\n"},"firmwareapi/pycom/machine/wdt.html":{"url":"firmwareapi/pycom/machine/wdt.html","title":"WDT","keywords":"","body":"WDT\nThe WDT is used to restart the system when the application crashes and ends up into a non recoverable state. After enabling, the application must \"feed\" the watchdog periodically to prevent it from expiring and resetting the system.\nQuick Usage Example\nfrom machine import WDT\nwdt = WDT(timeout=2000) # enable it with a timeout of 2 seconds\nwdt.feed()\n\nConstructors\nclass machine.WDT(id=0, timeout)\nCreate a WDT object and start it. The id can only be 0. See the init method for the parameters of initialisation.\nMethods\nwdt.init(timeout)\nInitialises the watchdog timer. The timeout must be given in milliseconds. Once it is running the WDT cannot be stopped but the timeout can be re-configured at any point in time.\nwdt.feed()\nFeed the WDT to prevent it from resetting the system. The application should place this call in a sensible place ensuring that the WDT is only fed after verifying that everything is functioning correctly.\n"},"firmwareapi/pycom/machine/timer.html":{"url":"firmwareapi/pycom/machine/timer.html","title":"Timer","keywords":"","body":"Timer\nclass Timer – Measure Time and Set Alarms\nTimers can be used for a great variety of tasks, like measuring time spans or being notified that a specific interval has elapsed.\nThese two concepts are grouped into two different subclasses:\nChrono: used to measure time spans. Alarm: to get interrupted after a specific interval.\nYou can create as many of these objects as needed.\n\nConstructors\nclass Timer.Chrono()\nCreate a chronometer object.\nclass Timer.Alarm(handler=None, s, * , ms, us, arg=None, periodic=False)\nCreate an Alarm object.\n\nhandler: will be called after the interval has elapsed. If set to None, the alarm will be disabled after creation.\narg: an optional argument can be passed to the callback handler function. If None is specified, the function will receive the object that triggered the alarm.\ns, ms, us: the interval can be specified in seconds (float), miliseconds (integer) or microseconds (integer). Only one at a time can be specified.\nperiodic: an alarm can be set to trigger repeatedly by setting this parameter to True.\n\nMethods\nTimer.sleep_us()\nDelay for a given number of microseconds, should be positive or 0 (for speed, the condition is not enforced). Internally it uses the same timer as the other elements of the Timer class. It compensates for the calling overhead, so for example, 100us should be really close to 100us. For times bigger than 10,000us it releases the GIL to let other threads run, so exactitude is not guaranteed for delays longer than that.\nclass Chrono\nCan be used to measure time spans.\nMethods\nchrono.start()\nStart the chronometer.\nchrono.stop()\nStop the chronometer.\nchrono.reset()\nReset the time count to 0.\nchrono.read()\nGet the elapsed time in seconds.\nchrono.read_ms()\nGet the elapsed time in milliseconds.\nchrono.read_us()\nGet the elapsed time in microseconds.\nExample:\nfrom machine import Timer\nimport time\n\nchrono = Timer.Chrono()\n\nchrono.start()\ntime.sleep(1.25) # simulate the first lap took 1.25 seconds\nlap = chrono.read() # read elapsed time without stopping\ntime.sleep(1.5)\nchrono.stop()\ntotal = chrono.read()\n\nprint()\nprint(\"\\nthe racer took %f seconds to finish the race\" % total)\nprint(\" %f seconds in the first lap\" % lap)\nprint(\" %f seconds in the last lap\" % (total - lap))\nclass Alarm – get interrupted after a specific interval\n\nclass Alarm\nUsed to get interrupted after a specific interval.\nMethods\nalarm.callback(handler, * , arg=None)\nSpecify a callback handler for the alarm. If set to None, the alarm will be disabled.\nAn optional argument arg can be passed to the callback handler function. If None is specified, the function will receive the object that triggered the alarm.\nalarm.cancel()\nDisables the alarm.\nExample:\nfrom machine import Timer\n\nclass Clock:\n\n def __init__(self):\n self.seconds = 0\n self.__alarm = Timer.Alarm(self._seconds_handler, 1, periodic=True)\n\n def _seconds_handler(self, alarm):\n self.seconds += 1\n print(\"%02d seconds have passed\" % self.seconds)\n if self.seconds == 10:\n alarm.cancel() # stop counting after 10 seconds\n\nclock = Clock()\n\nFor more information on how Pycom's products handle interrupts, see notes.\n\n"},"firmwareapi/pycom/machine/sd.html":{"url":"firmwareapi/pycom/machine/sd.html","title":"SD","keywords":"","body":"SD\nThe SD card class allows to configure and enable the memory card module of your Pycom module and automatically mount it as /sd as part of the file system. There is a single pin combination that can be used for the SD card, and the current implementation only works in 1-bit mode. The pin connections are as follows:\nP8: DAT0, P23: SCLK and P4: CMD (no external pull-up resistors are needed)\nIf you have one of the Pycom expansion boards, then simply insert the card into the micro SD socket and run your script.\nMake sure your SD card is formatted either as FAT16 or FAT32.\n\nQuick Example Usage:\nfrom machine import SD\nimport os\n\nsd = SD()\nos.mount(sd, '/sd')\n\n# check the content\nos.listdir('/sd')\n\n# try some standard file operations\nf = open('/sd/test.txt', 'w')\nf.write('Testing SD card write operations')\nf.close()\nf = open('/sd/test.txt', 'r')\nf.readall()\nf.close()\n\nConstructors\nclass machine.SD(id, ...)\nCreate a SD card object. See sd.init() for parameters if initialisation.\nMethods\nsd.init(id=0)\nEnable the SD card.\nsd.deinit()\nDisable the SD card.\nPlease note that the SD card library currently supports FAT16/32 formatted SD cards up to 32 GB. Future firmware updates will increase compatibility with additional formats and sizes.\n\n"},"firmwareapi/pycom/machine/can.html":{"url":"firmwareapi/pycom/machine/can.html","title":"CAN","keywords":"","body":"CAN\nThe CAN class supports the full CAN 2.0 specification with standard and extended frames, as well as acceptance filtering.\nThe ESP32 has a built-in CAN controller, but the transceiver needs to be added externally. A recommended device is the SN65HVD230.\nQuick Usage Example\nfrom machine import CAN\n\ncan = CAN(mode=CAN.NORMAL, baudrate=500000, pins=('P22', 'P23'))\ncan.send(id=12, data=bytes([1, 2, 3, 4, 5, 6, 7, 8]))\ncan.recv()\n\nConstructors\nclass machine.CAN(bus=0, ...)\nCreate an CAN object. See init for parameters of initialisation.:\n# only 1 CAN peripheral is available, so the bus must always be 0\ncan = CAN(0, mode=CAN.NORMAL, baudrate=500000, pins=('P22', 'P23')) # pin order is Tx, Rx\n\nMethods\ncan.init(mode=CAN.NORMAL, baudrate=500000, *, frame_format=CAN.FORMAT_STD, rx_queue_len=128, pins=('P22', 'P23'))\nInitialize the CAN controller. The arguments are:\n\nmode can take either CAN.NORMAL or CAN.SILENT. Silent mode is useful for sniffing the bus.\nbaudrate sets up the bus speed. Acceptable values are between 1 and 1000000.\nframe_format defines the frame format to be accepted by the receiver. Useful for filtering frames based on the identifier length. Can tale either CAN.FORMAT_STD, CAN.FORMAT_EXT, CAN.FORMAT_BOTH. If CAN.FORMAT_STD is selected, extended frames won't be received and vice-versa.\nrx_queue_len defines the number of messages than can be queued by the receiver. Due to CAN being a high traffic bus, large values are recommended (>= 128), otherwise messages will be dropped specially when no filtering is applied.\npins selects the Tx and Rx pins (in that order).\n\ncan.deinit()\nDisables the CAN bus.\ncan.send(id, * , data=None, rtr=False, extended=False)\nSend a CAN frame on the bus\n\nid is the identifier of the message.\ndata can take up to 8 bytes. It must be left empty is the message to be sent is a remote request (rtr=True).\nrtr set it to false to send a remote request.\nextnted specifies if the message identifier width should be 11bit (standard) or 29bit (extended).\n\nCan be used like:\ncan.send(id=0x0020, data=bytes([0x01, 0x02, 0x03, 0x04, 0x05]), extended=True) # sends 5 bytes with an extended identifier\n\ncan.send(id=0x010, data=bytes([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08])) # sends 8 bytes with an standard identifier\n\ncan.send(id=0x012, rtr=True) # sends a remote request for message id=0x12\n\ncan.recv(timeout=0)\nGet a message from the receive queue, and optionally specify a timeout value in s (can be a floating point value e.g. 0.2). This function returns None if no messages available. If a message is present, it will be returned as a named tuple with the following form:\n(id, data, rtr, extended)\n>>> can.recv()\n(id=0x012, data=b'123', rtr=False, extended=False)\n\ncan.soft_filter(mode, filter_list)\nSpecify a software filter accepting only the messages that pass the filter test.\nThere are 3 possible filter modes:\n\nCAN.FILTER_LIST allows to pass the list of IDs that should be accepted.\nCAN.FILTER_RANGE allows to pass a list or tuple of ID ranges that should be accepted.\nCAN.FILTER_MASK allows to pass a list of tuples of the form: (filter, mask).\n\nWith software filters all messages in the bus are received by the CAN controller but only the matching ones are passed to the RX queue. This means that the queue won't be filled up with non relevant messages, but the interrupt overhead will remain as normal. The filter_list can contain up to 32 elements.\nFor example:\ncan.soft_filter(CAN.FILTER_LIST, [0x100, 0x200, 0x300, 0x400]) # only accept identifiers from 0x100, 0x200, 0x300 and 0x400\n\ncan.soft_filter(CAN.FILTER_RANGE, [(0x001, 0x010), (0x020, 0x030), (0x040, 0x050)]) # only accept identifiers from 0x001 to 0x010, from 0x020 to 0x030 and from 0x040 to 0x050.\n\ncan.soft_filter(CAN.FILTER_MASK, [(0x100, 0x7FF), (0x200, 0x7FC)]) # more of the classic Filter and Mask method.\n\ncan.soft_filter(None) # disable soft filters, all messages are accepted\n\ncan.callback(trigger, handler=None, arg=None)\nSet a callback to be triggered when any of this 3 events are present:\n\ntrigger is the type of event that triggers the callback. Possible values are:\nCAN.RX_FRAME interrupt whenever a new frame is received.\nCAN.RX_FIFO_NOT_EMPTY interrupt when a frame is received on an empty FIFO.\nCAN.RX_FIFO_OVERRUN interrupt when a message is received and the FIFO is full.\n\n\n\nThe values can be OR-ed together, for instance trigger=CAN.RX_FRAME | CAN.RX_FIFO_OVERRUN\n\nhandler is the function to be called when the event happens. This function will receive one argument. Set handler to None to disable the callback.\narg is an optional argument to pass to the callback. If left empty or set to None, the function will receive the CAN object that triggered it.\n\nIt can be used like this:\nfrom machine import CAN\n\ncan = CAN(mode=CAN.NORMAL, baudrate=500000, pins=('P22', 'P23'))\n\ndef can_cb(can_o):\n print('CAN Rx:', can_o.recv())\n\ncan.callback(handler=can_cb, trigger=CAN.RX_FRAME)\n\ncan.events()\nThis method returns a value with bits sets (if any) indicating the events that have occurred in the bus. Please note that by calling this function the internal events registry is cleared automatically, therefore calling it immediately for a second time will most likely return a value of 0.\nConstants\nCAN.NORMAL, CAN.SILENT, CAN.FORMAT_STD, CAN.FORMAT_EXT, CAN.FORMAT_BOTH, CAN.RX_FRAME, CAN.RX_FIFO_NOT_EMPTY, CAN.RX_FIFO_OVERRUN, CAN.FILTER_LIST, CAN.FILTER_RANGE, CAN.FILTER_MASK\n"},"firmwareapi/pycom/machine/rmt.html":{"url":"firmwareapi/pycom/machine/rmt.html","title":"RMT","keywords":"RMT Remote Remote Controller Pulse","body":"RMT\nThe RMT (Remote Control) module is primarily designed to send and receive infrared remote control signals that use on-off-keying of a carrier frequency, but due to its design it can be used to generate various types of signals.\nQuick Usage Example: sending\nimport machine\n\n# create a RMT object for transmission\nrmt = machine.RMT(channel=3, gpio=\"P20\", tx_idle_level=0)\n# create series of bits to send \ndata = (1,0,1,0,1,0,1,0,1)\n# define duration of the bits, time unit depends on the selected RMT channel \nduration = 10000\n# send the signal \nrmt.send_pulses(duration, data)\n\nQuick Usage Example: receiving\nimport machine\n# create a RMT object\nrmt = machine.RMT(channel=3)\n# Configure RTM for receiving\nrmt.init(gpio=\"P20\", rx_idle_threshold=12000) \n# wait for any number of pulses until one longer than rx_idle_threshold \ndata = rmt.recv_pulses()\n\nConstructors\nclass machine.RMT(channel,...)\nConstruct an RMT object on the given channel. channel can be 2-7. With no additional parameters, the RMT object is created but not initialised. If extra arguments are given, the RMT is initialised for transmission or reception. See init for parameters of initialisation. The resolution which a pulse can be sent/received depends on the selected channel:\n\n\n\nChannel\nResolution\nMaximum Pulse Width\n\n\n\n\n0\nUsed by on-board LED\n\n\n\n1\nUsed by pycom.pulses_get()\n\n\n\n2\n100nS\n3.2768 ms\n\n\n3\n100nS\n3.2768 ms\n\n\n4\n1000nS\n32.768 ms\n\n\n5\n1000nS\n32.768 ms\n\n\n6\n3125nS\n102.4 ms\n\n\n7\n3125nS\n102.4 ms\n\n\n\nMethods\nrmt.init(gpio, rx_idle_threshold, rx_filter_threshold, tx_idle_level, tx_carrier)\nInitialise the RMT peripheral with the given parameters:\n\ngpio is the GPIO Pin to use.\nrx_idle_threshold is the maximum duration of a valid pulse. The represented time unit (resolution) depends on the selected channel, value can be 0-65535.\nrx_filter_threshold is the minimum duration of a valid pulse. The represented time unit (resolution) depends on the selected channel, value can be 0-31.\ntx_idle_level is the output signal's level after the transmission is finished, can be RMT.HIGH or RMT.LOW.\ntx_carrier is the modulation of the pulses to send.\n\nEither rx_idle_threshold or tx_idle_level must be defined, both cannot be given at the same time because a channel can be configured in RX or TX mode only. rx_filter_threshold is not mandatory parameter. If not given then all pulses are accepted with duration less than rx_idle_threshold. tx_carrier is not mandatory parameters. If not given no modulation is used on the sent pulses.\nThe tx_carrier parameter is a tuple with the following structure:\n\ncarrier_freq_hz is the carrier's frequency in Hz.\ncarrier_duty_percent is the duty percent of the carrier's signal, can be 0%-100%.\ncarrier_level is the level of the pulse to modulate, can be RMT.HIGH or RMT.LOW.\n\nrmt.deinit()\nDeinitialise the RMT object.\nIf an RMT object needs to be reconfigured from RX/TX to TX/RX, then either first deinit() must be called or the init() again with the desired configuration.\n\nrmt.pulses_get(pulses, timeout)\nReads in pulses from the GPIO pin.\n\npulses if not specified, this function will keep reading pulses until the\nrx_idle_threshold is exceeded. If it is specified this function will return\nthe exactly that number of pulses, ignoring anything shorter than\nrx_filter_threshold or longer than rx_idle_threshold.\n\ntimeout is specified, this function will return if the first pulse does\nnot occur within timeout microseconds. If not specified, it will wait\nindefinitely.\n\n\nReturn value: Tuple of items with the following structure: (level, duration):\n\nlevel represents the level of the received bit/pulse, can be 0 or 1.\nduration represents the duration of the received pulse, the time unit (resolution) depends on the selected channel.\n\nMaximum of 128 pulses can be received in a row without receiving \"idle\" signal. If the incoming pulse sequence contains more than 128 pulses the rest is dropped and the receiver waits for another sequence of pulses. The pulses_get function can be called to receive more than 128 pulses, however the above mentioned limitation should be kept in mind when evaluating the received data.\n\nrmt.pulses_send(duration, data, start_level)\nGenerates pulses as defined by the parameters below\n\nduration represents the duration of the pulses to be sent,\nthe time unit (resolution) depends on the selected channel.\n\ndata Tuple that represents the sequence of pulses to be sent, must be\ncomposed of 0 or 1 elements.\n\nstart_level defines the state (HIGH/LOW) of the first pulse given by\nduration if data is not given.\n\n\ndata must be a tuple and duration can be a tuple or a single number, with data being optional. In the case that only duration is provided, it must be a tuple and you must also provide start_level which will dictate the level of the first duration, the signal level then toggles between each duration value. If data is provided and duration is a single number, each pulse in data will have have an equal length as set by duration. If data and duration are provided as tuples, they must be of the same number of elements, with each pulse lasting its matching duration.\nConstants\n\nDefine the level of the pulse: RMT.LOW, RMT.HIGH\n\n"},"firmwareapi/pycom/network/":{"url":"firmwareapi/pycom/network/","title":"network","keywords":"","body":"network\nThis module provides access to network drivers and routing configuration. Network drivers for specific hardware are available within this module and are used to configure specific hardware network interfaces.\n"},"firmwareapi/pycom/network/wlan.html":{"url":"firmwareapi/pycom/network/wlan.html","title":"WLAN","keywords":"","body":"WLAN\nThis class provides a driver for the WiFi network processor in the module. Example usage:\nimport network\nimport time\n# setup as a station\nwlan = network.WLAN(mode=network.WLAN.STA)\nwlan.connect('your-ssid', auth=(network.WLAN.WPA2, 'your-key'))\nwhile not wlan.isconnected():\n time.sleep_ms(50)\nprint(wlan.ifconfig())\n\n# now use socket as usual\n\nQuick Usage Example\nimport machine\nfrom network import WLAN\n\n# configure the WLAN subsystem in station mode (the default is AP)\nwlan = WLAN(mode=WLAN.STA)\n# go for fixed IP settings (IP, Subnet, Gateway, DNS)\nwlan.ifconfig(config=('192.168.0.107', '255.255.255.0', '192.168.0.1', '192.168.0.1'))\nwlan.scan() # scan for available networks\nwlan.connect(ssid='mynetwork', auth=(WLAN.WPA2, 'my_network_key'))\nwhile not wlan.isconnected():\n pass\nprint(wlan.ifconfig())\n\nConstructors\nclass network.WLAN(id=0, ...)\nCreate a WLAN object, and optionally configure it. See init for params of configuration.\nThe WLAN constructor is special in the sense that if no arguments besides the id are given, it will return the already existing WLAN instance without re-configuring it. This is because WLAN is a system feature of the WiPy. If the already existing instance is not initialised it will do the same as the other constructors an will initialise it with default values.\n\nMethods\nwlan.init(mode, * , ssid=None, auth=None, channel=1, antenna=None, power_save=False, hidden=False)\nSet or get the WiFi network processor configuration.\nArguments are:\n\nmode can be either WLAN.STA, WLAN.AP, or WLAN.STA_AP.\nssid is a string with the SSID name. Only needed when mode is WLAN.AP.\nauth is a tuple with (sec, key). Security can be None, WLAN.WEP, WLAN.WPA, or WLAN.WPA2. The key is a string with the network password.\nIf sec is WLAN.WEP the key must be a string representing hexadecimal values (e.g. ABC1DE45BF). Only needed when mode is WLAN.AP.\n\n\nchannel a number in the range 1-11. Only needed when mode is WLAN.AP.\nantenna selects between the internal and the external antenna. Can be either WLAN.INT_ANT, WLAN.EXT_ANT. With our development boards it defaults to using the internal antenna, but in the case of an OEM module, the antenna pin (P12) is not used, so it's free to be\nused for other things.\n\npower_save enables or disables power save functions in STA mode.\n\nhidden only valid in WLAN.AP mode to create an access point with a hidden SSID when set to True.\n\nFor example, you can do:\n# create and configure as an access point\nwlan.init(mode=WLAN.AP, ssid='wipy-wlan', auth=(WLAN.WPA2,'www.wipy.io'), channel=7, antenna=WLAN.INT_ANT)\n\nor\n# configure as an station\nwlan.init(mode=WLAN.STA)\n\nTo use an external antenna, set P12 as output pin.\nPin('P12', mode=Pin.OUT)(True)\n\n\nwlan.deinit()\nDisables the WiFi radio.\nwlan.connect(ssid, * , auth=None, bssid=None, timeout=None, ca_certs=None, keyfile=None, certfile=None, identity=None)\nConnect to a wifi access point using the given SSID, and other security parameters.\n\nauth is a tuple with (sec, key). Security can be None, WLAN.WEP, WLAN.WPA, WLAN.WPA2 or WLAN.WPA2_ENT. The key is a string with the network password.\nIf sec is WLAN.WEP the key must be a string representing hexadecimal values (e.g. ABC1DE45BF).\nIf sec is WLAN.WPA2_ENT then the auth tuple can have either 3 elements: (sec, username, password), or just 1: (sec,). When passing the 3 element tuple, thekeyfile and certifle arguments must not be given.\n\n\nbssid is the MAC address of the AP to connect to. Useful when there are several APs with the same SSID.\ntimeout is the maximum time in milliseconds to wait for the connection to succeed.\nca_certs is the path to the CA certificate. This argument is not mandatory.\nkeyfile is the path to the client key. Only used if username and password are not part of the auth tuple.\ncertfile is the path to the client certificate. Only used if username and password are not part of the auth tuple.\nidentity is only used in case of WLAN.WPA2_ENT security. Needed by the server.\n\nThe ESP32 only handles certificates with pkcs8 format (but not the \"Traditional SSLeay RSAPrivateKey\" format). The private key should be RSA coded with 2048 bits at maximum.\n\nwlan.scan()\nPerforms a network scan and returns a list of named tuples with (ssid, bssid, sec, channel, rssi). Note that channel is always None since this info is not provided by the WiPy.\nwlan.disconnect()\nDisconnect from the WiFi access point.\nwlan.isconnected()\nIn case of STA mode, returns True if connected to a WiFi access point and has a valid IP address. In AP mode returns True when a station is connected, False otherwise.\nwlan.ifconfig(id=0, config=['dhcp' or configtuple])\nWhen id is 0, the configuration will be get/set on the Station interface. When id is 1 the configuration will be done for the AP interface.\nWith no parameters given returns a 4-tuple of (ip, subnet_mask, gateway, DNS_server).\nIf dhcp is passed as a parameter then the DHCP client is enabled and the IP params are negotiated with the AP.\nIf the 4-tuple config is given then a static IP is configured. For instance:\nwlan.ifconfig(config=('192.168.0.4', '255.255.255.0', '192.168.0.1', '8.8.8.8'))\n\nwlan.mode([mode])\nGet or set the WLAN mode.\nwlan.ssid([ssid])\nGet or set the SSID when in AP mode.\nwlan.auth([auth])\nGet or set the authentication type when in AP mode.\nwlan.channel([channel])\nGet or set the channel (only applicable in AP mode).\nwlan.antenna([antenna])\nGet or set the antenna type (external or internal).\nTo use an external antenna, set P12 as output pin.\nPin('P12', mode=Pin.OUT)(True)\n\n\nwlan.mac()\nGet a 6-byte long bytes object with the WiFI MAC address.\nConstants\n\nWLAN mode: WLAN.STA, WLAN.AP, WLAN.STA_AP\nWLAN network security: WLAN.WEP, WLAN.WPA, WLAN.WPA2, WLAN.WPA2_ENT\nAntenna type: WLAN.INT_ANT, WLAN.EXT_ANT\n\n"},"firmwareapi/pycom/network/server.html":{"url":"firmwareapi/pycom/network/server.html","title":"Server","keywords":"","body":"Server\nThe Server class controls the behaviour and the configuration of the FTP and telnet services running on the Pycom device. Any changes performed using this class' methods will affect both.\nExample:\nimport network\nserver = network.Server()\nserver.deinit() # disable the server\n# enable the server again with new settings\nserver.init(login=('user', 'password'), timeout=600)\n\nQuick Usage Example\nfrom network import Server\n\n# init with new user, password and seconds timeout\nserver = Server(login=('user', 'password'), timeout=60)\nserver.timeout(300) # change the timeout\nserver.timeout() # get the timeout\nserver.isrunning() # check whether the server is running or not\n\nConstructors\nclass network.Server(id, ...)\nCreate a server instance, see init for parameters of initialisation.\nMethods\nserver.init(* , login=('micro', 'python'), timeout=300)\nInit (and effectively start the server). Optionally a new user, password and timeout (in seconds) can be passed.\nserver.deinit()\nStop the server.\nserver.timeout([timeout_in_seconds])\nGet or set the server timeout.\nserver.isrunning()\nReturns True if the server is running (connected or accepting connections), False otherwise.\n"},"firmwareapi/pycom/network/bluetooth/":{"url":"firmwareapi/pycom/network/bluetooth/","title":"Bluetooth","keywords":"","body":"Bluetooth\nThis class provides a driver for the Bluetooth radio in the module. Currently, only basic BLE functionality is available.\nQuick Usage Example\nfrom network import Bluetooth\nimport time\nbt = Bluetooth()\nbt.start_scan(-1)\n\nwhile True:\n adv = bt.get_adv()\n if adv and bt.resolve_adv_data(adv.data, Bluetooth.ADV_NAME_CMPL) == 'Heart Rate':\n try:\n conn = bt.connect(adv.mac)\n services = conn.services()\n for service in services:\n time.sleep(0.050)\n if type(service.uuid()) == bytes:\n print('Reading chars from service = {}'.format(service.uuid()))\n else:\n print('Reading chars from service = %x' % service.uuid())\n chars = service.characteristics()\n for char in chars:\n if (char.properties() & Bluetooth.PROP_READ):\n print('char {} value = {}'.format(char.uuid(), char.read()))\n conn.disconnect()\n break\n except:\n print(\"Error while connecting or reading from the BLE device\")\n break\n else:\n time.sleep(0.050)\n\nBluetooth Low Energy (BLE)\nBluetooth low energy (BLE) is a subset of classic Bluetooth, designed for easy connecting and communicating between devices (in particular mobile platforms). BLE uses a methodology known as Generic Access Profile (GAP) to control connections and advertising.\nGAP allows for devices to take various roles but generic flow works with devices that are either a Server (low power, resource constrained, sending small payloads of data) or a Client device (commonly a mobile device, PC or Pycom Device with large resources and processing power). Pycom devices can act as both a Client and a Server.\nConstructors\nclass network.Bluetooth(id=0, ...)\nCreate a Bluetooth object, and optionally configure it. See init for params of configuration.\nExample:\nfrom network import Bluetooth\nbluetooth = Bluetooth()\n\nMethods\nbluetooth.init(id=0, mode=Bluetooth.BLE, antenna=None)\n\nid Only one Bluetooth peripheral available so must always be 0\nmode currently the only supported mode is Bluetooth.BLE\nantenna selects between the internal and the external antenna. Can be eitherBluetooth.INT_ANT, Bluetooth.EXT_ANT.\nWith our development boards it defaults to using the internal antenna, but in the case of an OEM module, the antenna pin (P12) is not used, so it's free to be used for other things.\n\n\nInitialises and enables the Bluetooth radio in BLE mode.\nTo use an external antenna, set P12 as output pin.\nPin('P12', mode=Pin.OUT)(True)\n\n\nbluetooth.deinit()\nDisables the Bluetooth radio.\nbluetooth.start_scan(timeout)\nStarts performing a scan listening for BLE devices sending advertisements. This function always returns immediately, the scanning will be performed on the background. The return value is None. After starting the scan the function get_adv() can be used to retrieve the advertisements messages from the FIFO. The internal FIFO has space to cache 16 advertisements.\nThe arguments are:\n\ntimeout specifies the amount of time in seconds to scan for advertisements, cannot be zero. If timeout is > 0, then the BLE radio will listen for advertisements until the specified value in seconds elapses. If timeout \n\nExamples:\nbluetooth.start_scan(10) # starts scanning and stop after 10 seconds\nbluetooth.start_scan(-1) # starts scanning indefinitely until bluetooth.stop_scan() is called\n\nbluetooth.stop_scan()\nStops an ongoing scanning process. Returns None.\nbluetooth.isscanning()\nReturns True if a Bluetooth scan is in progress. False otherwise.\nbluetooth.get_adv()\nGets an named tuple with the advertisement data received during the scanning. The tuple has the following structure: (mac, addr_type, adv_type, rssi, data)\n\nmac is the 6-byte ling mac address of the device that sent the advertisement.\naddr_type is the address type. See the constants section below for more details.\nadv_type is the advertisement type received. See the constants section below fro more details.\nrssi is signed integer with the signal strength of the advertisement.\ndata contains the complete 31 bytes of the advertisement message. In order to parse the data and get the specific types, the method resolve_adv_data() can be used.\n\nExample for getting mac address of an advertiser:\nimport ubinascii\n\nbluetooth = Bluetooth()\nbluetooth.start_scan(20) # scan for 20 seconds\n\nadv = bluetooth.get_adv() #\nubinascii.hexlify(adv.mac) # convert hexadecimal to ascii\n\nbluetooth.get_advertisements()\nSame as the get_adv() method, but this one returns a list with all the advertisements received.\nbluetooth.resolve_adv_data(data, data_type)\nParses the advertisement data and returns the requested data_type if present. If the data type is not present, the function returns None.\nArguments:\n\ndata is the bytes object with the complete advertisement data.\ndata_type is the data type to resolve from from the advertisement data. See constants section below for details.\n\nExample:\nimport ubinascii\nfrom network import Bluetooth\nbluetooth = Bluetooth()\n\nbluetooth.start_scan(20)\nwhile bluetooth.isscanning():\n adv = bluetooth.get_adv()\n if adv:\n # try to get the complete name\n print(bluetooth.resolve_adv_data(adv.data, Bluetooth.ADV_NAME_CMPL))\n\n mfg_data = bluetooth.resolve_adv_data(adv.data, Bluetooth.ADV_MANUFACTURER_DATA)\n\n if mfg_data:\n # try to get the manufacturer data (Apple's iBeacon data is sent here)\n print(ubinascii.hexlify(mfg_data))\n\nbluetooth.connect(mac_addr)\nOpens a BLE connection with the device specified by the mac_addr argument. This function blocks until the connection succeeds or fails. If the connections succeeds it returns a object of type GATTCConnection.\nConnections are initiated by the central device. There is a maximum of 4 simultaneous connections.\nbluetooth.connect('112233eeddff') # mac address is accepted as a string\n\nbluetooth.callback(trigger=None, handler=None, arg=None)\nCreates a callback that will be executed when any of the triggers occurs. The arguments are:\n\ntrigger can be either Bluetooth.NEW_ADV_EVENT, Bluetooth.CLIENT_CONNECTED, or Bluetooth.CLIENT_DISCONNECTED\nhandler is the function that will be executed when the callback is triggered.\narg is the argument that gets passed to the callback. If nothing is given the bluetooth object itself is used.\n\nAn example of how this may be used can be seen in the bluetooth.events() method.\nbluetooth.events()\nReturns a value with bit flags identifying the events that have occurred since the last call. Calling this function clears the events.\nExample of usage:\nfrom network import Bluetooth\n\nbluetooth = Bluetooth()\nbluetooth.set_advertisement(name='LoPy', service_uuid=b'1234567890123456')\n\ndef conn_cb (bt_o):\n events = bt_o.events() # this method returns the flags and clears the internal registry\n if events & Bluetooth.CLIENT_CONNECTED:\n print(\"Client connected\")\n elif events & Bluetooth.CLIENT_DISCONNECTED:\n print(\"Client disconnected\")\n\nbluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=conn_cb)\n\nbluetooth.advertise(True)\n\nbluetooth.set_advertisement(* , name=None, manufacturer_data=None, service_data=None, service_uuid=None)\nConfigure the data to be sent while advertising. If left with the default of None the data won't be part of the advertisement message.\nThe arguments are:\n\nname is the string name to be shown on advertisements.\nmanufacturer_data manufacturer data to be advertised (hint: use it for iBeacons).\nservice_data service data to be advertised.\nservice_uuid uuid of the service to be advertised.\n\nExample:\nbluetooth.set_advertisement(name=\"advert\", manufacturer_data=\"lopy_v1\")\n\nbluetooth.advertise([Enable])\nStart or stop sending advertisements. The set_advertisement() method must have been called prior to this one.\nbluetooth.service(uuid, * , isprimary=True, nbr_chars=1, start=True)\nCreate a new service on the internal GATT server. Returns a object of type BluetoothServerService.\nThe arguments are:\n\nuuid is the UUID of the service. Can take an integer or a 16 byte long string or bytes object.\nisprimary selects if the service is a primary one. Takes a bool value.\nnbr_chars specifies the number of characteristics that the service will contain.\nstart if True the service is started immediately.\n\nbluetooth.service('abc123')\n\nbluetooth.disconnect_client()\nCloses the BLE connection with the client.\nConstants\n\nBluetooth mode: Bluetooth.BLE\nAdvertisement type: Bluetooth.CONN_ADV, Bluetooth.CONN_DIR_ADV, Bluetooth.DISC_ADV, Bluetooth.NON_CONN_ADV, Bluetooth.SCAN_RSP\nAddress type: Bluetooth.PUBLIC_ADDR, Bluetooth.RANDOM_ADDR, Bluetooth.PUBLIC_RPA_ADDR, Bluetooth.RANDOM_RPA_ADDR\nAdvertisement data type: Bluetooth.ADV_FLAG, Bluetooth.ADV_16SRV_PART, Bluetooth.ADV_T16SRV_CMPL, Bluetooth.ADV_32SRV_PART, Bluetooth.ADV_32SRV_CMPL, Bluetooth.ADV_128SRV_PART, Bluetooth.ADV_128SRV_CMPL, Bluetooth.ADV_NAME_SHORT, Bluetooth.ADV_NAME_CMPL, Bluetooth.ADV_TX_PWR, Bluetooth.ADV_DEV_CLASS, Bluetooth.ADV_SERVICE_DATA, Bluetooth.ADV_APPEARANCE, Bluetooth.ADV_ADV_INT, Bluetooth.ADV_32SERVICE_DATA, Bluetooth.ADV_128SERVICE_DATA, Bluetooth.ADV_MANUFACTURER_DATA\nCharacteristic properties (bit values that can be combined): Bluetooth.PROP_BROADCAST, Bluetooth.PROP_READ, Bluetooth.PROP_WRITE_NR, Bluetooth.PROP_WRITE, Bluetooth.PROP_NOTIFY, Bluetooth.PROP_INDICATE, Bluetooth.PROP_AUTH, Bluetooth.PROP_EXT_PROP\nCharacteristic callback events: Bluetooth.CHAR_READ_EVENT, Bluetooth.CHAR_WRITE_EVENT, Bluetooth.NEW_ADV_EVENT, Bluetooth.CLIENT_CONNECTED, Bluetooth.CLIENT_DISCONNECTED, Bluetooth.CHAR_NOTIFY_EVENT\nAntenna type: Bluetooth.INT_ANT, Bluetooth.EXT_ANT\n\n"},"firmwareapi/pycom/network/bluetooth/gatt.html":{"url":"firmwareapi/pycom/network/bluetooth/gatt.html","title":"GATT","keywords":"","body":"GATT\nGATT stands for the Generic Attribute Profile and it defines the way that two Bluetooth Low Energy devices communicate between each other using concepts called Services and Characteristics. GATT uses a data protocol known as the Attribute Protocol (ATT), which is used to store/manage Services, Characteristics and related data in a lookup table.\nGATT comes into use once a connection is established between two devices, meaning that the device will have already gone through the advertising process managed by GAP. It's important to remember that this connection is exclusive; i.e. that only one client is connected to one server at a time. This means that the client will stop advertising once a connection has been made. This remains the case, until the connection is broken or disconnected.\nThe GATT Server, which holds the ATT lookup data and service and characteristic definitions, and the GATT Client (the phone/tablet), which sends requests to this server.\n"},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"url":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","title":"GATTCConnection","keywords":"","body":"GATTCConnection\nThe GATT Client is the device that requests data from the server, otherwise known as the master device (commonly this might be a phone/tablet/PC). All transactions are initiated by the master, which receives a response from the slave.\nMethods\nconnection.disconnect()\nCloses the BLE connection. Returns None.\nconnection.isconnected()\nReturns True if the connection is still open. False otherwise.\nExample:\nfrom network import Bluetooth\nimport ubinascii\nbluetooth = Bluetooth()\n\n# scan until we can connect to any BLE device around\nbluetooth.start_scan(-1)\nadv = None\nwhile True:\n adv = bluetooth.get_adv()\n if adv:\n try:\n bluetooth.connect(adv.mac)\n except:\n # start scanning again\n bluetooth.start_scan(-1)\n continue\n break\nprint(\"Connected to device with addr = {}\".format(ubinascii.hexlify(adv.mac)))\n\nconnection.services()\nPerforms a service search on the connected BLE peripheral (server) a returns a list containing objects of the class GATTCService if the search succeeds.\nExample:\n# assuming that a BLE connection is already open\nservices = connection.services()\nprint(services)\nfor service in services:\n print(service.uuid())\n\n"},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"url":"firmwareapi/pycom/network/bluetooth/gattccservice.html","title":"GATTCService","keywords":"","body":"GATTCService\nServices are used to categorise data up into specific chunks of data known as characteristics. A service may have multiple characteristics, and each service has a unique numeric ID called a UUID.\nThe following class allows control over Client services.\nMethods\nservice.isprimary()\nReturns True if the service is a primary one. False otherwise.\nservice.uuid()\nReturns the UUID of the service. In the case of 16-bit or 32-bit long UUIDs, the value returned is an integer, but for 128-bit long UUIDs the value returned is a bytes object.\nservice.instance()\nReturns the instance ID of the service.\nservice.characteristics()\nPerforms a get characteristics request on the connected BLE peripheral a returns a list containing objects of the class GATTCCharacteristic if the request succeeds.\n"},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"url":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","title":"GATTCCharacteristic","keywords":"","body":"GATTCCharacteristic\nThe smallest concept in GATT is the Characteristic, which encapsulates a single data point (though it may contain an array of related data, such as X/Y/Z values from a 3-axis accelerometer, longitude and latitude from a GPS, etc.).\nThe following class allows you to manage characteristics from a Client.\nMethods\ncharacteristic.uuid()\nReturns the UUID of the service. In the case of 16-bit or 32-bit long UUIDs, the value returned is an integer, but for 128-bit long UUIDs the value returned is a bytes object.\ncharacteristic.instance()\nReturns the instance ID of the service.\ncharacteristic.properties()\nReturns an integer indicating the properties of the characteristic. Properties are represented by bit values that can be OR-ed together. See the constants section for more details.\ncharacteristic.read()\nRead the value of the characteristic, sending a request to the GATT server. Returns a bytes object representing the characteristic value.\ncharacteristic.value()\nReturns the locally stored value of the characteristic without sending a read request to the GATT server. If the characteristic value hasn't been read from the GATT server yet, the value returned will be 0.\ncharacteristic.write(value)\nWrites the given value on the characteristic. For now it only accepts bytes object representing the value to be written.\ncharacteristic.write(b'x0f')\n\ncharacteristic.callback(trigger=None, handler=None, arg=None)\nThis method allows to register for notifications on the characteristic.\n\ntrigger can must be Bluetooth.CHAR_NOTIFY_EVENT.\nhandler is the function that will be executed when the callback is triggered.\narg is the argument that gets passed to the callback. If nothing is given, the characteristic object that owns the callback will be used.\n\n"},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"url":"firmwareapi/pycom/network/bluetooth/gattsservice.html","title":"GATTSService","keywords":"","body":"GATTSService\nThe GATT Server allows the device to act as a peripheral and hold its own ATT lookup data, server & characteristic definitions. In this mode, the device acts as a slave and a master must initiate a request.\nServices are used to categorise data up into specific chunks of data known as characteristics. A service may have multiple characteristics, and each service has a unique numeric ID called a UUID.\nThe following class allows control over Server services.\nMethods\nservice.start()\nStarts the service if not already started.\nservice.stop()\nStops the service if previously started.\nservice.characteristic(uuid, * , permissions, properties, value)\nCreates a new characteristic on the service. Returns an object of the class GATTSCharacteristic. The arguments are:\n\nuuid is the UUID of the service. Can take an integer or a 16 byte long string or bytes object.\npermissions configures the permissions of the characteristic. Takes an integer with a combination of the flags.\nproperties sets the properties. Takes an integer with an OR-ed combination of the flags.\nvalue sets the initial value. Can take an integer, a string or a bytes object.\n\nservice.characteristic('temp', value=25)\n\n"},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"url":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","title":"GATTSCharacteristic","keywords":"","body":"GATTSCharacteristic\nThe smallest concept in GATT is the Characteristic, which encapsulates a single data point (though it may contain an array of related data, such as X/Y/Z values from a 3-axis accelerometer, longitude and latitude from a GPS, etc.).\nThe following class allows you to manage Server characteristics.\nMethods\ncharacteristic.value([value])\nGets or sets the value of the characteristic. Can take an integer, a string or a bytes object.\ncharacteristic.value(123) # set characteristic value to an integer with the value 123\ncharacteristic.value() # get characteristic value\n\ncharacteristic.callback(trigger=None, handler=None, arg=None)\nCreates a callback that will be executed when any of the triggers occurs. The arguments are:\n\ntrigger can be either Bluetooth.CHAR_READ_EVENT or Bluetooth.CHAR_WRITE_EVENT.\nhandler is the function that will be executed when the callback is triggered.\narg is the argument that gets passed to the callback. If nothing is given, the characteristic object that owns the callback will be used.\n\nAn example of how this could be implemented can be seen in the characteristic.events() section.\ncharacteristic.events()\nReturns a value with bit flags identifying the events that have occurred since the last call. Calling this function clears the events.\nAn example of advertising and creating services on the device:\nfrom network import Bluetooth\n\nbluetooth = Bluetooth()\nbluetooth.set_advertisement(name='LoPy', service_uuid=b'1234567890123456')\n\ndef conn_cb (bt_o):\n events = bt_o.events()\n if events & Bluetooth.CLIENT_CONNECTED:\n print(\"Client connected\")\n elif events & Bluetooth.CLIENT_DISCONNECTED:\n print(\"Client disconnected\")\n\nbluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=conn_cb)\n\nbluetooth.advertise(True)\n\nsrv1 = bluetooth.service(uuid=b'1234567890123456', isprimary=True)\n\nchr1 = srv1.characteristic(uuid=b'ab34567890123456', value=5)\n\nchar1_read_counter = 0\ndef char1_cb_handler(chr):\n global char1_read_counter\n char1_read_counter += 1\n\n events = chr.events()\n if events & Bluetooth.CHAR_WRITE_EVENT:\n print(\"Write request with value = {}\".format(chr.value()))\n else:\n if char1_read_counter 0xF1:\n return char2_read_counter\n\nchar2_cb = chr2.callback(trigger=Bluetooth.CHAR_READ_EVENT, handler=char2_cb_handler)\n\n"},"firmwareapi/pycom/network/lora.html":{"url":"firmwareapi/pycom/network/lora.html","title":"LoRa","keywords":"","body":"LoRa\nThis class provides a LoRaWAN 1.0.2 compliant driver for the LoRa network processor in the LoPy and FiPy. Below is an example demonstrating LoRaWAN Activation by Personalisation usage:\nfrom network import LoRa\nimport socket\nimport ubinascii\nimport struct\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\n# create an ABP authentication params\ndev_addr = struct.unpack(\">l\", binascii.unhexlify('00000005'))[0]\nnwk_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\napp_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\n\n# join a network using ABP (Activation By Personalisation)\nlora.join(activation=LoRa.ABP, auth=(dev_addr, nwk_swkey, app_swkey))\n\n# create a LoRa socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\n# set the LoRaWAN data rate\ns.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)\n\n# make the socket non-blocking\ns.setblocking(False)\n\n# send some data\ns.send(bytes([0x01, 0x02, 0x03]))\n\n# get any data received...\ndata = s.recv(64)\nprint(data)\n\nPlease ensure that there is an antenna connected to your device before sending/receiving LoRa messages as improper use (e.g. without an antenna), may damage the device.\n\nAdditional Examples\nFor various other complete LoRa examples, check here for additional examples.\nConstructors\nclass network.LoRa(id=0, ...)\nCreate and configure a LoRa object. See init for params of configuration.\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\nMethods\nlora.init(mode, * ,region=LoRa.EU868, frequency=868000000, tx_power=14, bandwidth=LoRa.BW_125KHZ, sf=7, preamble=8, coding_rate=LoRa.CODING_4_5, power_mode=LoRa.ALWAYS_ON, tx_iq=False, rx_iq=False, adr=False, public=True, tx_retries=1, device_class=LoRa.CLASS_A)\nThis method is used to set the LoRa subsystem configuration and to specific raw LoRa or LoRaWAN.\nThe arguments are:\n\nmode can be either LoRa.LORA or LoRa.LORAWAN.\nregion can take the following values: LoRa.AS923, LoRa.AU915, LoRa.EU868 or LoRa.US915. If not provided this will default to LoRaEU868. If they are not specified, this will also set appropriate defaults for frequency and tx_power.\nfrequency accepts values between 863000000 and 870000000 in the 868 band, or between 902000000 and 928000000 in the 915 band.\ntx_power is the transmit power in dBm. It accepts between 2 and 14 for the 868 band, and between 5 and 20 in the 915 band.\nbandwidth is the channel bandwidth in KHz. In the 868 band the accepted values are LoRa.BW_125KHZ and LoRa.BW_250KHZ. In the 915 band the accepted values are LoRa.BW_125KHZ and LoRa.BW_500KHZ.\nsf sets the desired spreading factor. Accepts values between 7 and 12.\npreamble configures the number of pre-amble symbols. The default value is 8.\ncoding_rate can take the following values: LoRa.CODING_4_5, LoRa.CODING_4_6, LoRa.CODING_4_7 or LoRa.CODING_4_8.\npower_mode can be either LoRa.ALWAYS_ON, LoRa.TX_ONLY or LoRa.SLEEP. In ALWAYS_ON mode, the radio is always listening for incoming - packets whenever a transmission is not taking place. In TX_ONLY the radio goes to sleep as soon as the transmission completes. In SLEEP mode the radio is sent to sleep permanently and won't accept any commands until the power mode is changed.\ntx_iq enables TX IQ inversion.\nrx_iq enables RX IQ inversion.\nadr enables Adaptive Data Rate.\npublic selects between the public and private sync word.\ntx_retries sets the number of TX retries in LoRa.LORAWAN mode.\ndevice_class sets the LoRaWAN device class. Can be either LoRa.CLASS_A or LoRa.CLASS_C.\n\nIn LoRa.LORAWAN mode, only adr, public, tx_retries and device_class are used. All the other params will be ignored as they are handled by the LoRaWAN stack directly. On the other hand, in LoRa.LORA mode from those 4 arguments, only the public one is important in order to program the sync word. In LoRa.LORA mode adr, tx_retries and device_class are ignored since they are only relevant to the LoRaWAN stack.\n\nFor example, you can do:\n# initialize in raw LoRa mode\nlora.init(mode=LoRa.LORA, tx_power=14, sf=12)\n\nor\n# initialize in LoRaWAN mode\nlora.init(mode=LoRa.LORAWAN)\n\nlora.join(activation, auth, * ,timeout=None, dr=None)\nJoin a LoRaWAN network. Internally the stack will automatically retry every 15 seconds until a Join Accept message is received.\nThe parameters are:\n\nactivation: can be either LoRa.OTAA or LoRa.ABP.\nauth: is a tuple with the authentication data.\ntimeout: is the maximum time in milliseconds to wait for the Join Accept message to be received. If no timeout (or zero) is given, the call returns immediately and the status of the join request can be checked with lora.has_joined().\ndr: is an optional value to specify the initial data rate for the Join Request. Possible values are 0 to 5 for EU868, or 0 to 4 for US915.\n\nIn the case of LoRa.OTAA the authentication tuple is: (dev_eui, app_eui, app_key) where dev_eui is optional. If it is not provided the LoRa MAC will be used. Therefore, you can do OTAA in 2 different ways:\nlora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0) # the device MAC address is used as DEV_EUI\n\nor\nlora.join(activation=LoRa.OTAA, auth=(dev_eui, app_eui, app_key), timeout=0) # a custom DEV_EUI is specified\n\nExample:\nfrom network import LoRa\nimport socket\nimport time\nimport ubinascii\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\n# create an OTAA authentication parameters\napp_eui = ubinascii.unhexlify('ADA4DAE3AC12676B')\napp_key = ubinascii.unhexlify('11B0282A189B75B0B4D2D8C7FA38548B')\n\n# join a network using OTAA (Over the Air Activation)\nlora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)\n\n# wait until the module has joined the network\nwhile not lora.has_joined():\n time.sleep(2.5)\n print('Not yet joined...')\n\nIn the case of LoRa.ABP the authentication tuple is: (dev_addr, nwk_swkey, app_swkey). Example:\nfrom network import LoRa\nimport socket\nimport ubinascii\nimport struct\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\n# create an ABP authentication params\ndev_addr = struct.unpack(\">l\", ubinascii.unhexlify('00000005'))[0]\nnwk_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\napp_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\n\n# join a network using ABP (Activation By Personalisation)\nlora.join(activation=LoRa.ABP, auth=(dev_addr, nwk_swkey, app_swkey))\n\nlora.bandwidth([bandwidth])\nGet or set the bandwidth in raw LoRa mode (LoRa.LORA). Can be either LoRa.BW_125KHZ (0), LoRa.BW_250KHZ (1) or LoRa.BW_500KHZ (2):\n# get raw LoRa Bandwidth\nlora.bandwidth()\n\n# set raw LoRa Bandwidth\nlora.bandwidth(LoRa.BW_125KHZ)\n\nlora.frequency([frequency])\nGet or set the frequency in raw LoRa mode (LoRa.LORA). The allowed range is between 863000000 and 870000000 Hz for the 868 MHz band version or between 902000000 and 928000000 Hz for the 915 MHz band version.\n# get raw LoRa Frequency\nlora.frequency()\n\n# set raw LoRa Frequency\nlora.frequency(868000000)\n\nlora.coding_rate([coding_rate])\nGet or set the coding rate in raw LoRa mode (LoRa.LORA). The allowed values are: LoRa.CODING_4_5 (1), LoRa.CODING_4_6 (2), LoRa.CODING_4_7 (3) and LoRa.CODING_4_8 (4).\n# get raw LoRa Coding Rate\nlora.coding_rate()\n\n# set raw LoRa Coding Rate\nlora.coding_rate(LoRa.CODING_4_5)\n\nlora.preamble([preamble])\nGet or set the number of preamble symbols in raw LoRa mode (LoRa.LORA):\n# get raw LoRa preamble symbols\nlora.preamble()\n\n# set raw LoRa preamble symbols\nlora.preamble(LoRa.CODING_4_5)\n\nlora.sf([sf])\nGet or set the spreading factor value in raw LoRa mode (LoRa.LORA). The minimum value is 7 and the maximum is 12:\n# get raw LoRa spread factor value\nlora.sf()\n\n# set raw LoRa spread factor value\nlora.sf(7)\n\nlora.power_mode([power_mode])\nGet or set the power mode in raw LoRa mode (LoRa.LORA). The accepted values are: LoRa.ALWAYS_ON, LoRa.TX_ONLY, and LoRa.SLEEP:\nlora.stats()\nReturn a named tuple with useful information from the last received LoRa or LoRaWAN packet. The named tuple has the following form:\n(rx_timestamp, rssi, snr, sftx, sfrx, tx_trials, tx_power, tx_time_on_air, tx_counter, tx_frequency)\nExample:\nlora.stats()\n\nWhere:\n\nrx_timestamp is an internal timestamp of the last received packet with microseconds precision.\nrssi holds the received signal strength in dBm.\nsnr contains the signal to noise ratio id dB (as a single precision float).\nsfrx tells the data rate (in the case of LORAWAN mode) or the spreading factor (in the case of LORA mode) of the last packet received.\nsftx tells the data rate (in the case of LORAWAN mode) or the spreading factor (in the case of LORA mode) of the last packet transmitted.\ntx_trials is the number of tx attempts of the last transmitted packet (only relevant for LORAWAN confirmed packets).\ntx_power is the power of the last transmission (in dBm).\ntx_time_on_air is the time on air of the last transmitted packet (in ms).\ntx_counter is the number of packets transmitted.\ntx_frequency is the frequency used for the last transmission.\n\nlora.has_joined()\nReturns True if a LoRaWAN network has been joined. False otherwise.\nlora.add_channel(index, * , frequency, dr_min, dr_max)\nAdd a LoRaWAN channel on the specified index. If there's already a channel with that index it will be replaced with the new one.\nThe arguments are:\n\nindex: Index of the channel to add. Accepts values between 0 and 15 for EU and between 0 and 71 for US.\nfrequency: Centre frequency in Hz of the channel.\ndr_min: Minimum data rate of the channel (0-7).\ndr_max: Maximum data rate of the channel (0-7).\n\nExamples:\nlora.add_channel(index=0, frequency=868000000, dr_min=5, dr_max=6)\n\nlora.remove_channel(index)\nRemoves the channel from the specified index. On the 868MHz band the channels 0 to 2 cannot be removed, they can only be replaced by other channels using the lora.add_channel method. A way to remove all channels except for one is to add the same channel, 3 times on indexes 0, 1 and 2. An example can be seen below:\nlora.remove_channel()\n\nOn the 915MHz band there are no restrictions around this.\nlora.mac()\nReturns a byte object with the 8-Byte MAC address of the LoRa radio.\nlora.callback(trigger, handler=None, arg=None)\nSpecify a callback handler for the LoRa radio. The trigger types are LoRa.RX_PACKET_EVENT, LoRa.TX_PACKET_EVENT, and LoRa.TX_FAILED_EVENT\nThe LoRa.RX_PACKET_EVENT event is raised for every received packet. The LoRa.TX_PACKET_EVENT event is raised as soon as the packet transmission cycle ends, which includes the end of the receive windows (even if a downlink is received, the LoRa.TX_PACKET_EVENT will come last). In the case of non-confirmed transmissions, this will occur at the end of the receive windows, but, in the case of confirmed transmissions, this event will only be raised if the ack is received. If the ack is not received LoRa.TX_FAILED_EVENT will be raised after the number of tx_retries configured have been performed.\nAn example of how this callback functions can be seen the in method lora.events().\nlora.ischannel_free(rssi_threshold)\nThis method is used to check for radio activity on the current LoRa channel, and if the rssi of the measured activity is lower than the rssi_threshold given, the return value will be True, otherwise False. Example:\nlora.ischannel_free(-100)\n\nlora.set_battery_level(level)\nSet the battery level value that will be sent when the LoRaWAN MAC command that retrieves the battery level is received. This command is sent by the network and handled automatically by the LoRaWAN stack. The values should be according to the LoRaWAN specification:\n\n0 means that the end-device is connected to an external power source.\n1..254 specifies the battery level, 1 being at minimum and 254 being at maximum.\n255 means that the end-device was not able to measure the battery level.\n\nlora.set_battery_level(127) # 50% battery\n\nlora.events()\nThis method returns a value with bits sets (if any) indicating the events that have triggered the callback. Please note that by calling this function the internal events registry is cleared automatically, therefore calling it immediately for a second time will most likely return a value of 0.\nExample:\ndef lora_cb(lora):\n events = lora.events()\n if events & LoRa.RX_PACKET_EVENT:\n print('Lora packet received')\n if events & LoRa.TX_PACKET_EVENT:\n print('Lora packet sent')\n\nlora.callback(trigger=(LoRa.RX_PACKET_EVENT | LoRa.TX_PACKET_EVENT), handler=lora_cb)\n\nlora.nvram_save()\nSave the LoRaWAN state (joined status, network keys, packet counters, etc) in non-volatile memory in order to be able to restore the state when coming out of deepsleep or a power cycle.\nlora.nvram_save()\n\nlora.nvram_restore()\nRestore the LoRaWAN state (joined status, network keys, packet counters, etc) from non-volatile memory. State must have been previously stored with a call to nvram_save before entering deepsleep. This is useful to be able to send a LoRaWAN message immediately after coming out of deepsleep without having to join the network again. This can only be used if the current region matches the one saved.\nlora.nvram_restore()\n\nlora.nvram_erase()\nRemove the LoRaWAN state (joined status, network keys, packet counters, etc) from non-volatile memory.\nlora.nvram_erase()\n\nConstants\n\nLoRa stack mode: LoRa.LORA, LoRa.LORAWAN\nLoRaWAN join procedure: LoRa.OTAA, LoRa.ABP\nRaw LoRa power mode: LoRa.ALWAYS_ON, LoRa.TX_ONLY, LoRa.SLEEP\nRaw LoRa bandwidth: LoRa.BW_125KHZ, LoRa.BW_250KHZ, LoRa.BW_500KHZ\nRaw LoRa coding rate: LoRa.CODING_4_5, LoRa.CODING_4_6, LoRa.CODING_4_7, LoRa.CODING_4_8\nCallback trigger types (may be ORed): LoRa.RX_PACKET_EVENT, LoRa.TX_PACKET_EVENT, LoRa.TX_FAILED_EVENT\nLoRaWAN device class: LoRa.CLASS_A, LoRa.CLASS_C\nLoRaWAN regions: LoRa.AS923, LoRa.AU915, LoRa.EU868, LoRa.US915\n\nWorking with LoRa and LoRaWAN Sockets\nLoRa sockets are created in the following way:\nimport socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\nAnd they must be created after initialising the LoRa network card.\nLoRa sockets support the following standard methods from the socket module:\nsocket.close()\nUsage:\ns.close()\n\nsocket.bind(port_number)\nUsage:\ns.bind(1)\n\nThe bind() method is only applicable when the radio is configured in LoRa.LORAWAN mode.\n\nsocket.send(bytes)\nUsage:\ns.send(bytes([1, 2, 3]))\n\nor\ns.send('Hello')\n\nsocket.recv(bufsize)\nUsage:\ns.recv(128)\n\nsocket.recvfrom(bufsize)\nThis method is useful to know the destination port number of the message received. Returns a tuple of the form: (data, port)\nUsage:\ns.recvfrom(128)\n\nsocket.setsockopt(level, optname, value)\nSet the value of the given socket option. The needed symbolic constants are defined in the socket module (SO_* etc.). In the case of LoRa the values are always integers. Examples:\n# configuring the data rate\ns.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)\n\n# selecting non-confirmed type of messages\ns.setsockopt(socket.SOL_LORA, socket.SO_CONFIRMED, False)\n\n# selecting confirmed type of messages\ns.setsockopt(socket.SOL_LORA, socket.SO_CONFIRMED, True)\n\nSocket options are only applicable when the LoRa radio is used in LoRa.LORAWAN mode. When using the radio in LoRa.LORA mode, use the class methods to change the spreading factor, bandwidth and coding rate to the desired values.\n\nsocket.settimeout(value)\nSets the socket timeout value in seconds. Accepts floating point values.\nUsage:\ns.settimeout(5.5)\n\nsocket.setblocking(flag)\nUsage:\ns.setblocking(True)\n\n"},"firmwareapi/pycom/network/sigfox.html":{"url":"firmwareapi/pycom/network/sigfox.html","title":"Sigfox","keywords":"","body":"Sigfox\nSigfox is a Low Power Wide Area Network protocol that enables remote devices to connect using ultra-narrow band, UNB technology. The protocol is bi-directional, messages can both be sent up to and down from the Sigfox servers.\nWhen operating in RCZ2 and RCZ4 the module can only send messages on the default macro-channel (this is due to Sigfox network limitations). Therefore, the device needs to reset automatically to the default macro-channel after every 2 transmissions. However, due to FCC duty cycle limitations, there must a minimum of a 20s delay after resetting to the default macro-channel. Our API takes care of this, (and in real life applications you should not be in the need to send Sigfox messages that often), so it will wait for the necessary amount of time to make sure that the duty cycle restrictions are fulfilled.\nThis means that if you run a piece of test code like:\nfor i in range(1, 100):\n # send something\n s.send('Hello ' + str(i))\n\nThere will be a 20 second delay after every 2 packets.\n\nThis class provides a driver for the Sigfox network processor in the Sigfox enabled Pycom devices.\nQuick Usage Example\nfrom network import Sigfox\nimport socket\n\n# init Sigfox for RCZ1 (Europe)\nsigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)\n\n# create a Sigfox socket\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\n\n# make the socket blocking\ns.setblocking(True)\n\n# configure it as uplink only\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False)\n\n# send some bytes\ns.send(bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]))\n\nPlease ensure that there is an antenna connected to your device before sending/receiving Sigfox messages as in proper use (e.g. without an antenna), may damage the device.\n\nConstructors\nclass network.Sigfox(id=0, ...)\nCreate and configure a Sigfox object. See init for params of configuration. Examples:\n# configure radio for the Sigfox network, using RCZ1 (868 MHz)\nsigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)\n\n# configure radio for FSK, device to device across 912 MHz\nsigfox = Sigfox(mode=Sigfox.FSK, frequency=912000000)\n\nSigfox.FSK mode is not supported on LoPy 4 and FiPy.\n\nMethods\nsigfox.init(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1, * , frequency=None)\nSet the Sigfox radio configuration.\nThe arguments are:\n\nmode can be either Sigfox.SIGFOX or Sigfox.FSK. Sigfox.SIGFOX uses the Sigfox modulation and protocol while Sigfox.FSK allows to create point to point communication between 2 Devices using FSK modulation. Note: Sigfox.FSK mode is not supported on LoPy 4 and FiPy.\nrcz takes the following values: Sigfox.RCZ1, Sigfox.RCZ2, Sigfox.RCZ3, Sigfox.RCZ4. The rcz argument is only required if the mode is Sigfox.SIGFOX.\nfrequency sets the frequency value in FSK mode. Can take values between 863 and 928 MHz. \n\nThe SiPy comes in 2 different hardware flavours: a +14dBm Tx power version which can only work with RCZ1 and RCZ3 and a +22dBm version which works exclusively on RCZ2 and RCZ4.\n\nsigfox.mac()\nReturns a byte object with the 8-Byte MAC address of the Sigfox radio.\nsigfox.id()\nReturns a byte object with the 4-Byte bytes object with the Sigfox ID.\nsigfox.rssi()\nReturns a signed integer with indicating the signal strength value of the last received packet.\nsigfox.pac()\nReturns a byte object with the 8-Byte bytes object with the Sigfox PAC.\nTo return human-readable values you should import ubinascii and convert binary values to hexidecimal representation. For example:\nprint(ubinascii.hexlify(sigfox.mac()))\n\n\nsigfox.frequencies()\nReturns a tuple of the form: (uplink_frequency_hz, downlink_frequency_hz)\nsigfox.public_key([public])\nSets or gets the public key flag. When called passing a True value the Sigfox public key will be used to encrypt the packets. Calling it without arguments returns the state of the flag.\n# enable encrypted packets\nsigfox.public_key(True)\n\n# return state of public_key\nsigfox.public_key()\n\nConstants\n\nSigfox radio mode: sigfox.SIGFOX, sigfox.FSK .\nSIGFOX to specify usage of the Sigfox Public Network.\nFSK to specify device to device communication.\n\n\nSigfox zones: sigfox.RCZ1, sigfox.RCZ2, sigfox.RCZ3, sigfox.RCZ4\nRCZ1 to specify Europe, Oman & South Africa.\nRCZ2 for the USA, Mexico & Brazil.\nRCZ3 for Japan.\nRCZ4 for Australia, New Zealand, Singapore, Taiwan, Hong Kong, Colombia & Argentina.\n\n\n\nWorking with Sigfox Sockets\nSigfox sockets are created in the following way:\nimport socket\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\n\nAnd they must be created after initialising the Sigfox network card.\nSigfox sockets support the following standard methods from the socket module:\nsocket.close()\nUse it to close an existing socket.\nsocket.send(bytes)\nIn Sigfox mode the maximum data size is 12 bytes. In FSK the maximum is 64.\n# send a Sigfox payload of bytes\ns.send(bytes([1, 2, 3]))\n\n# send a Sigfox payload containing a string\ns.send('Hello')\n\nsocket.recv(bufsize)\nThis method can be used to receive a Sigfox downlink or FSK message.\n# size of buffer should be passed for expected payload, e.g. 64 bytes\ns.recv(64)\n\nsocket.setsockopt(level, optname, value)\nSet the value of the given socket option. The needed symbolic constants are defined in the socket module (SO_* etc.). In the case of Sigfox the values are always an integer. Examples:\n# wait for a downlink after sending the uplink packet\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, True)\n\n# make the socket uplink only\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False)\n\n# use the socket to send a Sigfox Out Of Band message\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_OOB, True)\n\n# disable Out-Of-Band to use the socket normally\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_OOB, False)\n\n# select the bit value when sending bit only packets\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_BIT, False)\n\nSending a Sigfox packet with a single bit is achieved by sending an empty string, i.e.:\nimport socket\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\n\n# send a 1 bit\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_BIT, True)\ns.send('')\nsocket.settimeout(value)\n# set timeout for the socket, e.g. 5 seconds\ns.settimeout(5.0)\nsocket.setblocking(flag)\n# specifies if socket should be blocking based upon Boolean flag.\ns.setblocking(True)\n\nIf the socket is set to blocking, your code will be wait until the socket completes sending/receiving.\nSigfox Downlink\nA Sigfox capable Pycom devices (SiPy) can both send and receive data from the Sigfox network. To receive data, a message must first be sent up to Sigfox, requesting a downlink message. This can be done by passing a True argument into the setsockopt() method.\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, True)\n\nAn example of the downlink procedure can be seen below:\n# init Sigfox for RCZ1 (Europe)\nsigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)\n\n# create a Sigfox socket\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\n\n# make the socket blocking\ns.setblocking(True)\n\n# configure it as DOWNLINK specified by 'True'\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, True)\n\n# send some bytes and request DOWNLINK\ns.send(bytes([1, 2, 3]))\n\n# await DOWNLINK message\ns.recv(32)\n\nSigfox FSK (Device to Device)\nTo communicate between two Sigfox capable devices, it may be used in FSK mode. Two devices are required to be set to the same frequency, both using FSK.\nSigfox.FSK mode is not supported on LoPy 4 and FiPy.\n\nDevice 1:\nsigfox = Sigfox(mode=Sigfox.FSK, frequency=868000000)\n\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\ns.setblocking(True)\n\nwhile True:\n s.send('Device-1')\n time.sleep(1)\n print(s.recv(64))\n\nDevice 2:\nsigfox = Sigfox(mode=Sigfox.FSK, frequency=868000000)\n\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\ns.setblocking(True)\n\nwhile True:\n s.send('Device-2')\n time.sleep(1)\n print(s.recv(64))\n\nRemember to use the correct frequency for your region (868 MHz for Europe, 912 MHz for USA, etc.)\n\n"},"firmwareapi/pycom/network/lte.html":{"url":"firmwareapi/pycom/network/lte.html","title":"LTE","keywords":"","body":"LTE\nThe LTE class provides access to the LTE-M/NB-IoT modem on the GPy and FiPy. LTE-M/NB-IoT are new categories of cellular protocols developed by the 3GPP and optimised for long battery life power and longer range. These are new protocols currently in the process of being deployed by mobile networks across the world.\nThe GPy and FiPy support both new LTE-M protocols:\n\nCat-M1: also known as LTE-M defines a 1.4 MHz radio channel size and about 375 kbps of throughput. It is optimised for coverage and long battery life, outperforming 2G/GPRS, while being similar to previous LTE standards.\nCat-NB1 also known as NB-IoT, defines a 200 kHz radio channel size and around 60 kbps of uplink speed. It's optimised for ultra low throughput and specifically designed for IoT devices with a very long battery life. NB-IoT shares some features with LTE such as operating in licensed spectrum, but it's a very different protocol. It should be noted that NB-IoT has many restrictions as does not offer full IP connectivity and does not support mobility. When moving between cells, you will need to reconnect.\n\nPlease note: The GPy and FiPy only support the two protocols above and are not compatible with older LTE standards.\n\nThe Sequans modem used on Pycom's cellular enabled modules can only work in one of these modes at a time. In order to switch between the two protocols you need to flash a different firmware to the Sequans modem. Instructions for this can be found here.\n\nAT Commands\nThe AT commands for the Sequans Monarch modem on the GPy/FiPy are available in a PDF file.\nAT Commands for Sequans\nConstructors\nclass network.LTE(id=0, ...)\nCreate and configure a LTE object. See init for params of configuration.\nfrom network import LTE\nlte = LTE()\n\nMethods\nlte.init(*, carrier=None)\nThis method is used to set up the LTE subsystem. After a deinit() this method can take several seconds to return waiting for the LTE modem to start-up. Optionally specify a carrier name. The available options are: verizon, at&t, standard. standard is generic for any carrier, and it's also the option used when no arguments are given.\nlte.deinit()\nDisables LTE modem completely. This reduces the power consumption to the minimum. Call this before entering deepsleep.\nlte.attach(*, band=None)\nEnable radio functionality and attach to the LTE Cat M1 network authorised by the inserted SIM card. Optionally specify the band to scan for networks. If no band (or None) is specified, all 6 bands will be scanned. The possible values for the band are: 3, 4, 12, 13, 20 and 28.\nlte.isattached()\nReturns True if the cellular mode is attached to the network. False otherwise.\nlte.dettach()\nDetach the modem from the LTE Cat M1 and disable the radio functionality.\nlte.connect(*, cid=1)\nStart a data session and obtain and IP address. Optionally specify a CID (Connection ID) for the data session. The arguments are:\n\ncid is a Connection ID. This is carrier specific, for Verizon use cid=3. For others like Telstra it should be cid=1.\n\nFor instance, to attach and connect to Verizon:\nimport time\nfrom network import LTE\n\nlte = LTE(carrier=\"verizon\")\nlte.attach(band=13)\n\nwhile not lte.isattached():\n time.sleep(0.5)\n print('Attaching...')\n\nlte.connect(cid=3)\nwhile not lte.isconnected():\n time.sleep(0.5)\n print('Connecting...')\n\n# Now use sockets as usual...\n\nlte.isconnected()\nReturns True if there is an active LTE data session and IP address has been obtained. False otherwise.\nlte.disconnect()\nEnd the data session with the network.\nlte.send_at_cmd(cmd)\nSend an AT command directly to the modem. Returns the raw response from the modem as a string object. IMPORTANT: If a data session is active (i.e. the modem is connected), sending the AT commands requires to pause and then resume the data session. This is all done automatically, but makes the whole request take around 2.5 seconds.\nExample:\nlte.send_at_cmd('AT+CEREG?') # check for network registration manually (sames as lte.isattached())\n\nOptionally the response can be parsed for pretty printing:\ndef send_at_cmd_pretty(cmd):\n response = lte.send_at_cmd(cmd).split('\\r\\n')\n for line in response:\n print(line)\n\nsend_at_cmd_pretty('AT!=\"showphy\"') # get the PHY status\nsend_at_cmd_pretty('AT!=\"fsm\"') # get the System FSM\n\nlte.imei()\nReturns a string object with the IMEI number of the LTE modem.\nlte.iccid()\nReturns a string object with the ICCID number of the SIM card.\nlte.reset()\nPerform a hardware reset on the cellular modem. This function can take up to 5 seconds to return as it waits for the modem to shutdown and reboot.\n"},"firmwareapi/pycom/aes.html":{"url":"firmwareapi/pycom/aes.html","title":"AES","keywords":"","body":"AES\nAES (Advanced Encryption Standard) is a symmetric block cipher standardised by NIST. It has a fixed data block size of 16 bytes. Its keys can be 128, 192, or 256 bits long.\nAES is implemented using the ESP32 hardware module.\n\nQuick Usage Example\nfrom crypto import AES\nimport crypto\nkey = b'notsuchsecretkey' # 128 bit (16 bytes) key\niv = crypto.getrandbits(128) # hardware generated random IV (never reuse it)\n\ncipher = AES(key, AES.MODE_CFB, iv)\nmsg = iv + cipher.encrypt(b'Attack at dawn')\n\n# ... after properly sent the encrypted message somewhere ...\n\ncipher = AES(key, AES.MODE_CFB, msg[:16]) # on the decryption side\noriginal = cipher.decrypt(msg[16:])\nprint(original)\n\nConstructors\nclass ucrypto.AES(key, mode, IV, * , counter, segment_size)\nCreate an AES object that will let you encrypt and decrypt messages.\nThe arguments are:\n\nkey (byte string) is the secret key to use. It must be 16 (AES-128), 24 (AES-192), or 32 (AES-256) bytes long.\nmode is the chaining mode to use for encryption and decryption. Default is AES.MODE_ECB.\nIV (byte string) initialisation vector. Should be 16 bytes long. It is ignored in modes AES.MODE_ECB and AES.MODE_CRT.\ncounter (byte string) used only for AES.MODE_CTR. Should be 16 bytes long. Should not be reused.\nsegment_size is the number of bits plaintext and ciphertext are segmented in. Is only used in AES.MODE_CFB. Supported values are AES.SEGMENT_8 and AES.SEGMENT_128\n\nMethods\nucrypto.encrypt()\nEncrypt data with the key and the parameters set at initialisation.\nucrypto.decrypt()\nDecrypt data with the key and the parameters set at initialisation.\nConstants\n\nAES.MODE_ECB: Electronic Code Book. Simplest encryption mode. It does not hide data patterns well (see this article for more info)\nAES.MODE_CBC: Cipher-Block Chaining. An Initialisation Vector (IV) is required.\nAES.MODE_CFB: Cipher feedback. plaintext and ciphertext are processed in segments of segment_size bits. Works a stream cipher.\nAES.MODE_CTR: Counter mode. Each message block is associated to a counter which must be unique across all messages that get encrypted with the same key.\nAES.SEGMENT_8, AES.SEGMENT_128: Length of the segment for AES.MODE_CFB\n\nTo avoid security issues, IV should always be a random number and should never be reused to encrypt two different messages. The same applies to the counter in CTR mode. You can use crypto.getrandbits() for this purpose.\n\n"},"firmwareapi/pycom/pycom.html":{"url":"firmwareapi/pycom/pycom.html","title":"pycom","keywords":"","body":"pycom\nThe pycom module contains functions to control specific features of the Pycom devices, such as the heartbeat RGB LED.\nQuick Usage Example\nimport pycom\n\npycom.heartbeat(False) # disable the heartbeat LED\npycom.heartbeat(True) # enable the heartbeat LED\npycom.heartbeat() # get the heartbeat state\npycom.rgbled(0xff00) # make the LED light up in green color\n\nMethods\npycom.heartbeat([enable])\nGet or set the state (enabled or disabled) of the heartbeat LED. Accepts and returns boolean values (True or False).\npycom.heartbeat_on_boot([enable])\nAllows you permanently disable or enable the heartbeat LED. Once this setting is set, it will persist between reboots. Note, this only comes into effect on the next boot, it does not stop the already running heartbeat.\npycom.rgbled(color)\nSet the colour of the RGB LED. The colour is specified as 24 bit value representing red, green and blue, where the red colour is represented by the 8 most significant bits. For instance, passing the value 0x00FF00 will light up the LED in a very bright green.\npycom.nvs_set(key, value)\nSet the value of the specified key in the NVRAM memory area of the external flash. Data stored here is preserved across resets and power cycles. Value can only take 32-bit integers at the moment. Example:\nimport pycom\n\npycom.nvs_set('temp', 25)\npycom.nvs_set('count', 10)\n\npycom.nvs_get(key)\nGet the value the specified key from the NVRAM memory area of the external flash. Example:\nimport pycom\n\npulses = pycom.nvs_get('count')\n\nIf a non-existing key is given the returned value will be None.\npycom.nvs_erase(key)\nErase the given key from the NVRAM memory area.\npycom.nvs_erase_all()\nErase the entire NVRAM memory area.\npycom.wifi_on_boot([enable])\nGet or set the WiFi on boot flag. When this flag is set to True, the AP with the default SSID (lopy-wlan-xxx for example) will be enabled as part of the boot process. If the flag is set to False, the module will boot with WiFi disabled until it's enabled by the script via the WLAN class. This setting is stored in non-volatile memory which preserves it across resets and power cycles. Example:\nimport pycom\n\npycom.wifi_on_boot(True) # enable WiFi on boot\npycom.wifi_on_boot() # get the wifi on boot flag\n\npycom.wdt_on_boot([enable])\nEnables the WDT at boot time with the timeout in ms set by the function wdt_on_boot_timeout. If this flag is set, the application needs to reconfigure the WDT with a new timeout and feed it regularly to avoid a reset.\nimport pycom\n\npycom.wdt_on_boot(True) # enable WDT on boot\npycom.wdt_on_boot() # get the WDT on boot flag\n\npycom.wdt_on_boot_timeout([timeout])\nSets or gets the WDT on boot timeout in milliseconds. The minimum value is 5000 ms.\nimport pycom\n\npycom.wdt_on_boot_timeout(10000) # set the timeout to 5000ms\npycom.wdt_on_boot_timeout() # get the WDT timeout value\n\npycom.pulses_get(pin, timeout)\nReturn a list of pulses at pin. The methods scans for transitions at pin and returns a list of tuples, each telling the pin value and the duration in microseconds of that value. pin is a pin object, which must have set to INP or OPEN_DRAIN mode. The scan stops if not transitions occurs within timeout milliseconds.\nExample:\n# get the raw data from a DHT11/DHT22/AM2302 sensor\nfrom machine import Pin\nfrom pycom import pulses_get\nfrom time import sleep_ms\n\npin = Pin(\"G7\", mode=Pin.OPEN_DRAIN)\npin(0)\nsleep_ms(20)\npin(1)\ndata = pulses_get(pin, 100)\n\npycom.ota_start()\npycom.ota_write(buffer)\npycom.ota_finish()\nPerform a firmware update. These methods are internally used by a firmware update though FTP. The update starts with a call to ota_start(), followed by a series of calls to ota_write(buffer), and is terminated with ota_finish(). After reset, the new image gets active. buffer shall hold the image data to be written, in arbitrary sizes. A block size of 4096 is recommended.\nExample:\n# Firmware update by reading the image from the SD card\n#\nfrom pycom import ota_start, ota_write, ota_finish\nfrom os import mount\nfrom machine import SD\n\nBLOCKSIZE = const(4096)\nAPPIMG = \"/sd/appimg.bin\"\n\nsd = SD()\nmount(sd, '/sd')\n\nwith open(APPIMG, \"rb\") as f:\n buffer = bytearray(BLOCKSIZE)\n mv = memoryview(buffer)\n size=0\n ota_start()\n while True:\n chunk = f.readinto(buffer)\n if chunk > 0:\n ota_write(mv[:chunk])\n size += chunk\n print(\"\\r%7d \" % size, end=\"\")\n else:\n break\n ota_finish()\n\nInstead of reading the data to be written from a file, it can obviously also be received from a server using any suitable protocol, without the need to store it in the devices file system.\n"},"firmwareapi/micropython/":{"url":"firmwareapi/micropython/","title":"MicroPython Modules","keywords":"","body":"MicroPython Modules\nThe following list contains the standard Python libraries, MicroPython-specific libraries and Pycom specific modules that are available on the Pycom devices.\nThe standard Python libraries have been \"micro-ified\" to fit in with the philosophy of MicroPython. They provide the core functionality of that module and are intended to be a drop-in replacement for the standard Python library.\nSome modules are available by an u-name, and also by their non-u-name. The non-u-name can be overridden by a file of that name in your package path. For example, import json will first search for a file json.py or directory json and load that package if it's found. If nothing is found, it will fallback to loading the built-in ujson module.\n\n"},"firmwareapi/micropython/micropython.html":{"url":"firmwareapi/micropython/micropython.html","title":"micropython","keywords":"","body":"micropython\nMethods\nmicropython.alloc_emergency_exception_buf(size)\nAllocate size bytes of RAM for the emergency exception buffer (a good size is around 100 bytes). The buffer is used to create exceptions in cases when normal RAM allocation would fail (eg within an interrupt handler) and therefore give useful traceback information in these situations.\nA good way to use this function is to place it at the start of a main script (e.g. boot.py or main.py) and then the emergency exception buffer will be active for all the code following it.\nmicropython.const(expr)\nUsed to declare that the expression is a constant so that the compile can optimise it. The use of this function should be as follows:\nfrom micropython import const \n\nCONST_X = const(123)\nCONST_Y = const(2 * CONST_X + 1)\n\nConstants declared this way are still accessible as global variables from outside the module they are declared in. On the other hand, if a constant begins with an underscore then it is hidden, it is not available as a global variable, and does not take up any memory during execution.\nThis const function is recognised directly by the MicroPython parser and is provided as part of the micropython module mainly so that scripts can be written which run under both CPython and MicroPython, by following the above pattern.\nmicropython.opt_level([level])\nIf level is given then this function sets the optimisation level for subsequent compilation of scripts, and returns None. Otherwise it returns the current optimisation level.\nmicropython.mem_info([verbose])\nPrint information about currently used memory. If the verbose argument is given then extra information is printed.\nThe information that is printed is implementation dependent, but currently includes the amount of stack and heap used. In verbose mode it prints out the entire heap indicating which blocks are used and which are free.\nmicropython.qstr_info([verbose])\nPrint information about currently interned strings. If the verbose argument is given then extra information is printed.\nThe information that is printed is implementation dependent, but currently includes the number of interned strings and the amount of RAM they use. In verbose mode it prints out the names of all RAM-interned strings.\nmicropython.stack_use()\nReturn an integer representing the current amount of stack that is being used. The absolute value of this is not particularly useful, rather it should be used to compute differences in stack usage at different points.\nmicropython.heap_lock()\nmicropython.heap_unlock()\nLock or unlock the heap. When locked no memory allocation can occur and a MemoryError will be raised if any heap allocation is attempted.\nThese functions can be nested, i.e. heap_lock() can be called multiple times in a row and the lock-depth will increase, and then heap_unlock() must be called the same number of times to make the heap available again.\nmicropython.kbd_intr(chr)\nSet the character that will raise a KeyboardInterrupt exception. By default this is set to 3 during script execution, corresponding to Ctrl-C. Passing -1 to this function will disable capture of Ctrl-C, and passing 3 will restore it.\nThis function can be used to prevent the capturing of Ctrl-C on the incoming stream of characters that is usually used for the REPL, in case that stream is used for other purposes.\n"},"firmwareapi/micropython/uctypes.html":{"url":"firmwareapi/micropython/uctypes.html","title":"uctypes","keywords":"","body":"uctypes\nThis module implements \"foreign data interface\" for MicroPython. The idea behind it is similar to CPython's ctypes modules, but the actual API is different, streamlined and optimised for small size. The basic idea of the module is to define data structure layout with about the same power as the C language allows, and the access it using familiar dot-syntax to reference sub-fields.\nModule ustruct Standard Python way to access binary data structures (doesn't scale well to large and complex structures).\n\nDefining Structure Layout\nStructure layout is defined by a \"descriptor\" - a Python dictionary which encodes field names as keys and other properties required to access them as associated values. Currently, uctypes requires explicit specification of offsets for each field. Offset are given in bytes from a structure start.\nFollowing are encoding examples for various field types:\n\nScalar types:\n\n\"field_name\": uctypes.UINT32 | 0\n\nIn other words, value is scalar type identifier OR-ed with field offset (in bytes) from the start of the structure.\n\nRecursive structures:\n\n\"sub\": (2, {\n \"b0\": uctypes.UINT8 | 0,\n \"b1\": uctypes.UINT8 | 1,\n})\n\nI.e. value is a 2-tuple, first element of which is offset, and second is a structure descriptor dictionary (note: offsets in recursive descriptors are relative to a structure it defines).\n\nArrays of Primitive Types:\n\n\"arr\": (uctypes.ARRAY | 0, uctypes.UINT8 | 2),\n\nI.e. value is a 2-tuple, first element of which is ARRAY flag OR-ed with offset, and second is scalar element type OR-ed number of elements in array.\n\nArrays of Aggregate Types:\n\n\"arr2\": (uctypes.ARRAY | 0, 2, {\"b\": uctypes.UINT8 | 0}),\n\nI.e. value is a 3-tuple, first element of which is ARRAY flag OR-ed with offset, second is a number of elements in array, and third is descriptor of element type.\n\nPointer to a primitive type:\n\n\"ptr\": (uctypes.PTR | 0, uctypes.UINT8),\n\nI.e. value is a 2-tuple, first element of which is PTR flag OR-ed with offset, and second is scalar element type.\n\nPointer to an aggregate type:\n\n\"ptr2\": (uctypes.PTR | 0, {\"b\": uctypes.UINT8 | 0}),\n\nI.e. value is a 2-tuple, first element of which is PTR flag OR-ed with offset, second is descriptor of type pointed to.\n\nBitfields:\n\n\"bitf0\": uctypes.BFUINT16 | 0 | 0 \nI.e. value is type of scalar value containing given bitfield (typenames are similar to scalar types, but prefixes with \"BF\"), OR-ed with offset for scalar value containing the bitfield, and further OR-ed with values for bit offset and bit length of the bitfield within scalar value, shifted by BF_POS and BF_LEN positions, respectively. Bitfield position is counted from the least significant bit, and is the number of right-most bit of a field (in other words, it's a number of bits a scalar needs to be shifted right to extra the bitfield).\nIn the example above, first UINT16 value will be extracted at offset 0 (this detail may be important when accessing hardware registers, where particular access size and alignment are required), and then bitfield whose rightmost bit is least-significant bit of this UINT16, and length is 8 bits, will be extracted - effectively, this will access least-significant byte of UINT16.\nNote that bitfield operations are independent of target byte endianness, in particular, example above will access least-significant byte of UINT16 in both little- and big-endian structures. But it depends on the least significant bit being numbered 0. Some targets may use different numbering in their native ABI, but uctypes always uses normalised numbering described above.\nModule Contents\nclass uctypes.struct(addr, descriptor, layout_type=NATIVE)\nInstantiate a \"foreign data structure\" object based on structure address in memory, descriptor (encoded as a dictionary), and layout type (see below).\nuctypes.LITTLE_ENDIAN\nLayout type for a little-endian packed structure. (Packed means that every field occupies exactly as many bytes as defined in the descriptor, i.e. the alignment is 1).\nuctypes.BIG_ENDIAN\nLayout type for a big-endian packed structure.\nuctypes.NATIVE\nLayout type for a native structure - with data endianness and alignment conforming to the ABI of the system on which MicroPython runs.\nuctypes.sizeof(struct)\nReturn size of data structure in bytes. Argument can be either structure class or specific instantiated structure object (or its aggregate field).\nuctypes.addressof(obj)\nReturn address of an object. Argument should be bytes, bytearray or other object supporting buffer protocol (and address of this buffer is what actually returned).\nuctypes.bytes_at(addr, size)\nCapture memory at the given address and size as bytes object. As bytes object is immutable, memory is actually duplicated and copied into bytes object, so if memory contents change later, created object retains original value.\nuctypes.bytearray_at(addr, size)\nCapture memory at the given address and size as bytearray object. Unlike bytes_at() function above, memory is captured by reference, so it can be both written too, and you will access current value at the given memory address.\nStructure Descriptors and Instantiating Structure Objects\nGiven a structure descriptor dictionary and its layout type, you can instantiate a specific structure instance at a given memory address using uctypes.struct() constructor. Memory address usually comes from following sources:\n\nPredefined address, when accessing hardware registers on a baremetal system. Lookup these addresses in datasheet for a particular MCU/SoC.\nAs a return value from a call to some FFI (Foreign Function Interface) function.\nFrom uctypes.addressof(), when you want to pass arguments to an FFI function, or alternatively, to access some data for I/O (for example, data read from a file or network socket).\n\nStructure objects\nStructure objects allow accessing individual fields using standard dot notation: my_struct.substruct1.field1. If a field is of scalar type, getting it will produce a primitive value (Python integer or float) corresponding to the value contained in a field. A scalar field can also be assigned to.\nIf a field is an array, its individual elements can be accessed with the standard subscript operator [] - both read and assigned to.\nIf a field is a pointer, it can be dereferenced using [0] syntax (corresponding to C * operator, though [0] works in C too). Subscripting a pointer with other integer values but 0 are supported too, with the same semantics as in C.\nSumming up, accessing structure fields generally follows C syntax, except for pointer dereference, when you need to use [0] operator instead of *.\nLimitations\nAccessing non-scalar fields leads to allocation of intermediate objects to represent them. This means that special care should be taken to layout a structure which needs to be accessed when memory allocation is disabled (e.g. from an interrupt). The recommendations are:\n\nAvoid nested structures. For example, instead of mcu_registers.peripheral_a.register1, define separate layout descriptors for each peripheral, to be accessed as peripheral_a.register1.\nAvoid other non-scalar data, like array. For example, instead of peripheral_a.register[0] use peripheral_a.register0.\n\nNote that these recommendations will lead to decreased readability and conciseness of layouts, so they should be used only if the need to access structure fields without allocation is anticipated (it's even possible to define 2 parallel layouts - one for normal usage, and a restricted one to use when memory allocation is prohibited).\n"},"firmwareapi/micropython/sys.html":{"url":"firmwareapi/micropython/sys.html","title":"sys","keywords":"","body":"sys\nMethods\nsys.exit(retval=0)\nTerminate current program with a given exit code. Underlyingly, this function raise as SystemExit exception. If an argument is given, its value given as an argument to SystemExit.\nsys.print_exception(exc, file=sys.stdout)\nPrint exception with a traceback to a file-like object file (or sys.stdout by default).\nDifference to CPython\nThis is simplified version of a function which appears in the traceback module in CPython. Unlike traceback.print_exception(), this function takes just exception value instead of exception type, exception value, and traceback object; file argument should be positional; further arguments are not supported. CPython-compatible traceback module can be found in micropython-lib.\n\nConstants\n\nsys.argv: A mutable list of arguments the current program was started with.\nsys.byteorder: The byte order of the system (\"little\" or \"big\").\nsys.implementation: Object with information about the current Python implementation. For MicroPython, it has following attributes:\n\nname - string \"micropython\"\nversion - tuple (major, minor, micro), e.g. (1, 7, 0)\nThis object is the recommended way to distinguish MicroPython from other Python implementations (note that it still may not exist in the very minimal ports).\n\n\n\n\nDifference to CPython\nCPython mandates more attributes for this object, but the actual useful bare minimum is implemented in MicroPython.\n\n\nsys.maxsize: Maximum value which a native integer type can hold on the current platform, or maximum value representable by MicroPython integer type, if it's smaller than platform max value (that is the case for MicroPython ports without long int support).\n\nThis attribute is useful for detecting \"bitness\" of a platform (32-bit vs 64-bit, etc.). It's recommended to not compare this attribute to some value directly, but instead count number of bits in it:\nbits = 0\nv = sys.maxsize\nwhile v:\n bits += 1\n v >>= 1\nif bits > 32:\n # 64-bit (or more) platform\nelse:\n # 32-bit (or less) platform\n # Note that on 32-bit platform, value of bits may be less than 32\n # (e.g. 31) due to peculiarities described above, so use \"> 16\",\n # \"> 32\", \"> 64\" style of comparisons.\n\n\nsys.modules: Dictionary of loaded modules. On some ports, it may not include builtin modules.\nsys.path: A mutable list of directories to search for imported modules.\nsys.platform: The platform that MicroPython is running on. For OS/RTOS ports, this is usually an identifier of the OS, e.g. linux. For baremetal ports, it is an identifier of a board, e.g. pyboard for the original MicroPython reference board. It thus can be used to distinguish one board from another. If you need to check whether your program runs on MicroPython (vs other Python implementation), use sys.implementation instead.\nsys.stderr: Standard error stream.\nsys.stdin: Standard input stream.\nsys.stdout: Standard output stream.\nsys.version: Python language version that this implementation conforms to, as a string.\nsys.version_info: Python language version that this implementation conforms to, as a tuple of ints.\n\n"},"firmwareapi/micropython/uos.html":{"url":"firmwareapi/micropython/uos.html","title":"uos","keywords":"","body":"uos\nThe uos module contains functions for filesystem access and urandom function.\nPort Specifics\nThe filesystem has / as the root directory and the available physical drives are accessible from here. They are currently:\n\n/flash – the internal flash filesystem\n/sd – the SD card (if it exists)\n\nMethods\nuos.uname()\nReturn information about the system, firmware release version, and MicroPython interpreter version.\nuos.chdir(path)\nChange current directory.\nuos.getcwd()\nGet the current directory.\nuos.listdir([dir])\nWith no argument, list the current directory. Otherwise list the given directory.\nuos.mkdir(path)\nCreate a new directory.\nuos.remove(path)\nRemove a file.\nuos.rmdir(path)\nRemove a directory.\nuos.rename(old_path, new_path)\nRename a file.\nuos.stat(path)\nGet the status of a file or directory.\nThe return value is a tuple with the following 10 values, in order:\n\nst_mode: protection bits.\nst_ino: inode number. (not implemented, returns 0)\nst_dev: device. (not implemented, returns 0)\nst_nlink: number of hard links. (not implemented, returns 0)\nst_uid: user id of owner. (not implemented, returns 0)\nst_gid: group id of owner. (not implemented, returns 0)\nst_size: size of file in bytes.\nst_atime: time of most recent access.\nst_mtime: time of most recent content modification.\nst_ctime: time of most recent metadata change.\n\nuos.getfree(path)\nReturns the free space (in KiB) in the drive specified by path.\nuos.sync()\nSync all filesystems.\nuos.urandom(n)\nReturn a bytes object with n random bytes.\nuos.unlink(path)\nAlias for the remove() method.\nuos.mount(block_device, mount_point, * , readonly=False)\nMounts a block device (like an SD object) in the specified mount point. Example:\nos.mount(sd, '/sd')\nuos.unmount(path)\n\nUnmounts a previously mounted block device from the given path.\nuos.mkfs(block_device or path)\nFormats the specified path, must be either /flash or /sd. A block device can also be passed like an SD object before being mounted.\nuos.dupterm(stream_object)\nDuplicate the terminal (the REPL) on the passed stream-like object. The given object must at least implement the read() and write() methods.\nConstants\n\nuos.sep: Separation character used in paths\n\n"},"firmwareapi/micropython/array.html":{"url":"firmwareapi/micropython/array.html","title":"array","keywords":"","body":"array\nSee Python array for more information.\nSupported format codes: b, B, h, H, i, I, l, L, q, Q, f, d (the latter 2 depending on the floating-point support).\nClasses\nclass array.array(typecode[, iterable])\nCreate array with elements of given type. Initial contents of the array are given by an iterable. If it is not provided, an empty array is created.\nMethods\narray.append(val)\nAppend new element to the end of array, growing it.\narray.extend(iterable)\nAppend new elements as contained in an iterable to the end of array, growing it.\n"},"firmwareapi/micropython/cmath.html":{"url":"firmwareapi/micropython/cmath.html","title":"cmath","keywords":"","body":"cmath\nThe cmath module provides some basic mathematical functions for working with complex numbers. Floating point support required for this module.\nMethods\ncmath.cos(z)\nReturn the cosine of z.\ncmath.exp(z)\nReturn the exponential of z.\ncmath.log(z)\nReturn the natural logarithm of z. The branch cut is along the negative real axis.\ncmath.log10(z)\nReturn the base-10 logarithm of z. The branch cut is along the negative real axis.\ncmath.phase(z)\nReturns the phase of the number z, in the range (-pi, +pi).\ncmath.polar(z)\nReturns, as a tuple, the polar form of z.\ncmath.rect(r, phi)\nReturns the complex number with modulus r and phase phi.\ncmath.sin(z)\nReturn the sine of z.\ncmath.sqrt(z)\nReturn the square-root of z.\nConstants\n\ncmath.e: Base of the natural logarithm\ncmath.pi: The ratio of a circle's circumference to its diameter\n\n"},"firmwareapi/micropython/math.html":{"url":"firmwareapi/micropython/math.html","title":"math","keywords":"","body":"math\nThe math module provides some basic mathematical functions for working with floating-point numbers. Floating point support required for this module.\nMethods\nmath.acos(x)\nReturn the inverse cosine of x.\nmath.acosh(x)\nReturn the inverse hyperbolic cosine of x.\nmath.asin(x)\nReturn the inverse sine of x.\nmath.asinh(x)\nReturn the inverse hyperbolic sine of x.\nmath.atan(x)\nReturn the inverse tangent of x.\nmath.atan2(y, x)\nReturn the principal value of the inverse tangent of y/x.\nmath.atanh(x)\nReturn the inverse hyperbolic tangent of x.\nmath.ceil(x)\nReturn an integer, being x rounded towards positive infinity.\nmath.copysign(x, y)\nReturn x with the sign of y.\nmath.cos(x)\nReturn the cosine of x.\nmath.cosh(x)\nReturn the hyperbolic cosine of x.\nmath.degrees(x)\nReturn radians x converted to degrees.\nmath.erf(x)\nReturn the error function of x.\nmath.erfc(x)\nReturn the complementary error function of x.\nmath.exp(x)\nReturn the exponential of x.\nmath.expm1(x)\nReturn exp(x) - 1.\nmath.fabs(x)\nReturn the absolute value of x.\nmath.floor(x)\nReturn an integer, being x rounded towards negative infinity.\nmath.fmod(x, y)\nReturn the remainder of x/y.\nmath.frexp(x)\nDecomposes a floating-point number into its mantissa and exponent. The returned value is the tuple (m, e) such that x == m * 2**e exactly. If x == 0 then the function returns (0.0, 0), otherwise the relation 0.5 holds.\nmath.gamma(x)\nReturn the gamma function of x.\nmath.isfinite(x)\nReturn True if x is finite.\nmath.isinf(x)\nReturn True if x is infinite.\nmath.isnan(x)\nReturn True if x is not-a-number\nmath.ldexp(x, exp)\nReturn x * (2**exp).\nmath.lgamma(x)\nReturn the natural logarithm of the gamma function of x.\nmath.log(x)\nReturn the natural logarithm of x.\nmath.log10(x)\nReturn the base-10 logarithm of x.\nmath.log2(x)\nReturn the base-2 logarithm of x.\nmath.modf(x)\nReturn a tuple of two floats, being the fractional and integral parts of x. Both return values have the same sign as x.\nmath.pow(x, y)\nReturns x to the power of y.\nmath.radians(x)\nReturn degrees x converted to radians.\nmath.sin(x)\nReturn the sine of x.\nmath.sinh(x)\nReturn the hyperbolic sine of x.\nmath.sqrt(x)\nReturn the square root of x.\nmath.tan(x)\nReturn the tangent of x.\nmath.tanh(x)\nReturn the hyperbolic tangent of x.\nmath.trunc(x)\nReturn an integer, being x rounded towards 0.\nConstants\n\nmath.e: Base of the natural logarithm\nmath.pi: The ratio of a circle's circumference to its diameter\n\n"},"firmwareapi/micropython/gc.html":{"url":"firmwareapi/micropython/gc.html","title":"gc","keywords":"","body":"gc\nMethods\ngc.enable()\nEnable automatic garbage collection.\ngc.disable()\nDisable automatic garbage collection. Heap memory can still be allocated, and garbage collection can still be initiated manually using gc.collect().\ngc.collect()\nRun a garbage collection.\ngc.mem_alloc()\nReturn the number of bytes of heap RAM that are allocated.\ngc.mem_free()\nReturn the number of bytes of available heap RAM.\n"},"firmwareapi/micropython/ubinascii.html":{"url":"firmwareapi/micropython/ubinascii.html","title":"ubinascii","keywords":"","body":"ubinascii\nThis module implements conversions between binary data and various encodings of it in ASCII form (in both directions).\nMethods\nubinascii.hexlify(data[, sep])\nConvert binary data to hexadecimal representation. Returns bytes string.\nDifference to CPython\nIf additional argument, sep is supplied, it is used as a separator between hexadecimal values.\n\nubinascii.unhexlify(data)\nConvert hexadecimal data to binary representation. Returns bytes string. (i.e. inverse of hexlify)\nubinascii.a2b_base64(data)\nConvert Base64-encoded data to binary representation. Returns bytes string.\nubinascii.b2a_base64(data)\nEncode binary data in Base64 format. Returns string.\n"},"firmwareapi/micropython/ujson.html":{"url":"firmwareapi/micropython/ujson.html","title":"ujson","keywords":"","body":"ujson\nThis modules allows to convert between Python objects and the JSON data format.\nMethods\nujson.dumps(obj)\nReturn obj represented as a JSON string.\nujson.loads(str)\nParse the JSON str and return an object. Raises ValueError if the string is not correctly formed.\nujson.load(fp)\nParse contents of fp (a .read()-supporting file-like object containing a JSON document). Raises ValueError if the content is not correctly formed.\n"},"firmwareapi/micropython/ure.html":{"url":"firmwareapi/micropython/ure.html","title":"ure","keywords":"","body":"ure\nThis module implements regular expression operations. Regular expression syntax supported is a subset of CPython re module (and actually is a subset of POSIX extended regular expressions).\nSupported operators are:\n. Match any character. [] Match set of characters. Individual characters and ranges are supported.\n^\n$\n?\n*\n+\n??\n*?\n+?\n\nCounted repetitions ({m,n}), more advanced assertions, named groups, etc. are not supported.\nMethods\nure.compile(regex)\nCompile regular expression, return regex object.\nure.match(regex, string)\nMatch regex against string. Match always happens from starting position in a string.\nure.search(regex, string)\nSearch regex in a string. Unlike match, this will search string for first position which matches regex (which still may be 0 if regex is anchored).\nure.DEBUG\nFlag value, display debug information about compiled expression.\nRegex objects\nCompiled regular expression. Instances of this class are created using ure.compile().\nregex.match(string)\nregex.search(string)\nregex.split(string, max_split=-1)\nMatch objects\nMatch objects as returned by match() and search() methods.\nmatch.group([index])\nOnly numeric groups are supported.\n"},"firmwareapi/micropython/usocket.html":{"url":"firmwareapi/micropython/usocket.html","title":"usocket","keywords":"","body":"usocket\nThis module provides access to the BSD socket interface.\nSee corresponding CPython module for comparison.\nSocket Address Format(s)\nFunctions below which expect a network address, accept it in the format of (ipv4_address, port), where ipv4_address is a string with dot-notation numeric IPv4 address, e.g. 8.8.8.8, and port is integer port number in the range 1-65535. Note the domain names are not accepted as ipv4_address, they should be resolved first using socket.getaddrinfo().\nMethods\nsocket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)\nCreate a new socket using the given address family, socket type and protocol number.\nsocket.getaddrinfo(host, port)\nTranslate the host/port argument into a sequence of 5-tuples that contain all the necessary arguments for creating a socket connected to that service. The list of 5-tuples has following structure:\n(family, type, proto, canonname, sockaddr) The following example shows how to connect to a given url:\ns = socket.socket()\ns.connect(socket.getaddrinfo('www.micropython.org', 80)[0][-1])\n\nExceptions\nsocket.error, socket.timeout\nConstants\n\nFamily types: socket.AF_INET, socket.AF_LORA\nSocket types: socket.SOCK_STREAM, socket.SOCK_DGRAM, socket.SOCK_RAW\nSocket protocols: socket.IPPROTO_UDP, socket.IPPROTO_TCP\nSocket options layers: socket.SOL_SOCKET, socket.SOL_LORA, socket.SOL_SIGFOX\nIP socket options: socket.SO_REUSEADDR\nLoRa socket options: socket.SO_CONFIRMED, socket.SO_DR\nSigfox socket options: socket.SO_RX, socket.SO_TX_REPEAT, socket.SO_OOB, socket.SO_BIT\n\nclass Socket\nMethods\nsocket.close()\nMark the socket closed. Once that happens, all future operations on the socket object will fail. The remote end will receive no more data (after queued data is flushed).\nSockets are automatically closed when they are garbage-collected, but it is recommended to close() them explicitly, or to use a with statement around them.\nsocket.bind(address)\nBind the socket to address. The socket must not already be bound. The address parameter must be a tuple containing the IP address and the port.\nIn the case of LoRa sockets, the address parameter is simply an integer with the port number, for instance: s.bind(1)\n\nsocket.listen([backlog])\nEnable a server to accept connections. If backlog is specified, it must be at least 0 (if it's lower, it will be set to 0); and specifies the number of unaccepted connections that the system will allow before refusing new connections. If not specified, a default reasonable value is chosen.\nsocket.accept()\nAccept a connection. The socket must be bound to an address and listening for connections. The return value is a pair (conn, address) where conn is a new socket object usable to send and receive data on the connection, and address is the address bound to the socket on the other end of the connection.\nsocket.connect(address)\nConnect to a remote socket at address.\nsocket.send(bytes)\nSend data to the socket. The socket must be connected to a remote socket.\nsocket.sendall(bytes)\nAlias of socket.send(bytes).\nsocket.recv(bufsize)\nReceive data from the socket. The return value is a bytes object representing the data received. The maximum amount of data to be received at once is specified by bufsize.\nsocket.sendto(bytes, address)\nSend data to the socket. The socket should not be connected to a remote socket, since the destination socket is specified by address.\nsocket.recvfrom(bufsize)\nReceive data from the socket. The return value is a pair (bytes, address) where bytes is a bytes object representing the data received and address is the address of the socket sending the data.\nsocket.setsockopt(level, optname, value)\nSet the value of the given socket option. The needed symbolic constants are defined in the socket module (SO_* etc.). The value can be an integer or a bytes-like object representing a buffer.\nsocket.settimeout(value)\nSet a timeout on blocking socket operations. The value argument can be a nonnegative floating point number expressing seconds, or None. If a non-zero value is given, subsequent socket operations will raise a timeout exception if the timeout period value has elapsed before the operation has completed. If zero is given, the socket is put in non-blocking mode. If None is given, the socket is put in blocking mode.\nsocket.setblocking(flag)\nSet blocking or non-blocking mode of the socket: if flag is false, the socket is set to non-blocking, else to blocking mode.\nThis method is a shorthand for certain settimeout() calls:\nsock.setblocking(True) is equivalent to sock.settimeout(None)\nsock.setblocking(False) is equivalent to sock.settimeout(0.0)\n\nsocket.makefile(mode='rb')\nReturn a file object associated with the socket. The exact returned type depends on the arguments given to makefile(). The support is limited to binary modes only (rb and wb). CPython's arguments: encoding, errors, and newline are not supported.\nThe socket must be in blocking mode; it can have a timeout, but the file object's internal buffer may end up in a inconsistent state if a timeout occurs.\nDifference to CPython\nClosing the file object returned by makefile() WILL close the original socket as well.\n\nsocket.read(size)\nRead up to size bytes from the socket. Return a bytes object. If size is not given, it behaves just like socket.readall(), see below.\nsocket.readall()\nRead all data available from the socket until EOF. This function will not return until the socket is closed.\nsocket.readinto(buf[, nbytes])\nRead bytes into the buf. If nbytes is specified then read at most that many bytes. Otherwise, read at most len(buf) bytes.\nReturn value: number of bytes read and stored into buf.\nsocket.readline()\nRead a line, ending in a newline character.\nReturn value: the line read.\nsocket.write(buf)\nWrite the buffer of bytes to the socket.\nReturn value: number of bytes written.\n"},"firmwareapi/micropython/select.html":{"url":"firmwareapi/micropython/select.html","title":"select","keywords":"","body":"select\nThis module provides functions to wait for events on streams (select streams which are ready for operations).\nPyboard specifics\nPolling is an efficient way of waiting for read/write activity on multiple objects. Current objects that support polling are: pyb.UART, pyb.USB_VCP.\nMethods\nselect.poll()\nCreate an instance of the Poll class.\nselect.select(rlist, wlist, xlist[, timeout])\nWait for activity on a set of objects.\nThis function is provided for compatibility and is not efficient. Usage of Poll is recommended instead.\nclass Poll\nMethods\npoll.register(obj[, eventmask])\nRegister obj for polling. eventmask is logical OR of:\n\nselect.POLLIN - data available for reading\nselect.POLLOUT - more data can be written\nselect.POLLERR - error occurred\nselect.POLLHUP - end of stream/connection termination detected\neventmask defaults to select.POLLIN | select.POLLOUT.\n\n\npoll.unregister(obj)\nUnregister obj from polling.\npoll.modify(obj, eventmask)\nModify the eventmask for obj.\npoll.poll([timeout])\nWait for at least one of the registered objects to become ready. Returns list of (obj, event, ...) tuples, event element specifies which events happened with a stream and is a combination of select.POLL* constants described above. There may be other elements in tuple, depending on a platform and version, so don't assume that its size is 2. In case of timeout, an empty list is returned.\nTimeout is in milliseconds.\n"},"firmwareapi/micropython/utime.html":{"url":"firmwareapi/micropython/utime.html","title":"utime","keywords":"","body":"utime\nThe utime module provides functions for getting the current time and date, measuring time intervals, and for delays.\nTime Epoch: Pycom's ESP32 port uses standard for POSIX systems epoch of 1970-01-01 00:00:00 UTC.\nMaintaining actual calendar date/time\nThis requires a Real Time Clock (RTC). On systems with underlying OS (including some RTOS), an RTC may be implicit. Setting and maintaining actual calendar time is responsibility of OS/RTOS and is done outside of MicroPython, it just uses OS API to query date/time. On baremetal ports however system time depends on machine.RTC() object. The current calendar time may be set using machine.RTC().datetime(tuple) function, and maintained by following means:\n\nBy a backup battery (which may be an additional, optional component for a particular board).\nUsing networked time protocol (requires setup by a port/user).\nSet manually by a user on each power-up (many boards then maintain RTC time across hard resets, though some may require setting it again in such case).\n\nIf actual calendar time is not maintained with a system/MicroPython RTC, functions below which require reference to current absolute time may behave not as expected.\nMethods\nutime.gmtime([secs])\nConvert a time expressed in seconds since the Epoch (see above) into an 8-tuple which contains: (year, month, mday, hour, minute, second, weekday, yearday) If secs is not provided or None, then the current time from the RTC is used.\n\nyear includes the century (for example 2014).\nmonth is 1-12\nmday is 1-31\nhour is 0-23\nminute is 0-59\nsecond is 0-59\nweekday is 0-6 for Mon-Sun\nyearday is 1-366\n\nutime.localtime([secs])\nLike gmtime() but converts to local time. If secs is not provided or None, the current time from the RTC is used.\nutime.mktime()\nThis is inverse function of localtime. It's argument is a full 8-tuple which expresses a time as per localtime. It returns an integer which is the number of seconds since Jan 1, 2000.\nutime.sleep(seconds)\nSleep for the given number of seconds. seconds can be a floating-point number to sleep for a fractional number of seconds. Note that other MicroPython ports may not accept floating-point argument, for compatibility with them use sleep_ms() and sleep_us() functions.\nutime.sleep_ms(ms)\nDelay for given number of milliseconds, should be positive or 0.\nutime.sleep_us(us)\nDelay for given number of microseconds, should be positive or 0\nutime.ticks_ms()\nReturns uptime, in milliseconds.\nutime.ticks_us()\nJust like ticks_ms above, but in microseconds.\nutime.ticks_cpu()\nSame as ticks_us, but faster.\nutime.ticks_diff(old, new)\nMeasure period between consecutive calls to ticks_ms(), ticks_us(), or ticks_cpu(). The value returned by these functions may wrap around at any time, so directly subtracting them is not supported. ticks_diff() should be used instead. \"old\" value should actually precede \"new\" value in time, or result is undefined. This function should not be used to measure arbitrarily long periods of time (because ticks_*() functions wrap around and usually would have short period). The expected usage pattern is implementing event polling with timeout:\n# Wait for GPIO pin to be asserted, but at most 500us\nstart = time.ticks_us()\nwhile pin.value() == 0:\n if time.ticks_diff(start, time.ticks_us()) > 500:\n raise TimeoutError\n\nutime.time()\nReturns the number of seconds, as an integer, since the Epoch, assuming that underlying RTC is set. If an RTC is not set, this function returns number of seconds since power up or reset). If you want to develop portable MicroPython application, you should not rely on this function to provide higher than second precision. If you need higher precision, use ticks_ms() and ticks_us() functions, if you need calendar time, localtime() without an argument is a better choice.\nutime.timezone([secs])\nSet or get the timezone offset, in seconds. If secs is not provided, it returns the current value.\nIn MicroPython, time.timezone works the opposite way to Python. In Python, to get the local time, you write local_time = utc - timezone, while in MicroPython it is local_time = utc + timezone.\n\n"},"firmwareapi/micropython/uhashlib.html":{"url":"firmwareapi/micropython/uhashlib.html","title":"uhashlib","keywords":"","body":"uhashlib\nThis module implements binary data hashing algorithms. MD5 and SHA are supported. By limitations in the hardware, only one active hashing operation is supported at a time.\nConstructors\nclass uhashlib.md5([data])\nCreate a MD5 hasher object and optionally feed data into it.\nclass uhashlib.sha1([data])\nCreate a SHA-1 hasher object and optionally feed data into it.\nclass uhashlib.sha224([data])\nCreate a SHA-224 hasher object and optionally feed data into it.\nclass uhashlib.sha256([data])\nCreate a SHA-256 hasher object and optionally feed data into it.\nclass uhashlib.sha384([data])\nCreate a SHA-384 hasher object and optionally feed data into it.\nclass uhashlib.sha512([data])\nCreate a SHA-512 hasher object and optionally feed data into it.\nMethods\nhash.update(data)\nFeed more binary data into hash.\nhash.digest()\nReturn hash for all data passed through hash, as a bytes object. After this method is called, more data cannot be fed into hash any longer.\nhash.hexdigest()\nThis method is NOT implemented. Use ubinascii.hexlify(hash.digest()) to achieve a similar effect.\n"},"firmwareapi/micropython/ussl.html":{"url":"firmwareapi/micropython/ussl.html","title":"ussl","keywords":"","body":"ussl\nThis module provides access to Transport Layer Security (often known as \"Secure Sockets Layer\") encryption and peer authentication facilities for network sockets, both client-side and server-side.\nMethods\nssl.wrap_socket(sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ca_certs=None)\nTakes an instance sock of socket.socket, and returns an instance of ssl.SSLSocket, a subtype of socket.socket, which wraps the underlying socket in an SSL context. Example:\nimport socket\nimport ssl\ns = socket.socket()\nss = ssl.wrap_socket(s)\nss.connect(socket.getaddrinfo('www.google.com', 443)[0][-1])\n\nCertificates must be used in order to validate the other side of the connection, and also to authenticate ourselves with the other end. Such certificates must be stored as files using the FTP server, and they must be placed in specific paths with specific names.\nFor instance, to connect to the Blynk servers using certificates, take the file ca.pem located in the blynk examples folder and put it in /flash/cert/. Then do:\nimport socket\nimport ssl\ns = socket.socket()\nss = ssl.wrap_socket(s, cert_reqs=ssl.CERT_REQUIRED, ca_certs='/flash/cert/ca.pem')\nss.connect(socket.getaddrinfo('cloud.blynk.cc', 8441)[0][-1])\n\nSSL sockets inherit all methods and from the standard sockets, see the usocket module.\nExceptions\n\nssl.SSLError\n\nConstants\n\nssl.CERT_NONE, ssl.CERT_OPTIONAL, ssl.CERT_REQUIRED: Supported values in cert_reqs\n\n"},"firmwareapi/micropython/ucrypto.html":{"url":"firmwareapi/micropython/ucrypto.html","title":"ucrypto","keywords":"","body":"ucrypto\nThis module provides native support for cryptographic algorithms. It's loosely based on PyCrypto.\nClasses\n\nclass AES - Advanced Encryption Standard\n\nMethods\ncrypto.getrandbits(bits)\nReturns a bytes object filled with random bits obtained from the hardware random number generator.\nAccording to the ESP32 Technical Reference Manual, such bits \"... can be used as the basis for cryptographical operations\". \"These true random numbers are generated based on the noise in the Wi-Fi/BT RF system. When Wi-Fi and BT are disabled, the random number generator will give out pseudo-random numbers.\"\nThe parameter bits is rounded upwards to the nearest multiple of 32 bits.\nCryptography is not a trivial business. Doing things the wrong way could quickly result in decreased or no security. Please document yourself in the subject if you are depending on encryption to secure important information.\n\n"},"firmwareapi/micropython/ustruct.html":{"url":"firmwareapi/micropython/ustruct.html","title":"ustruct","keywords":"","body":"ustruct\nSee Python struct for more information.\nSupported size/byte order prefixes: @, , !.\nSupported format codes: b, B, h, H, i, I, l, L, q, Q, s, P, f, d (the latter 2 depending on the floating-point support).\nMethods\nustruct.calcsize(fmt)\nReturn the number of bytes needed to store the given fmt.\nustruct.pack(fmt, v1, v2, ...)\nPack the values v1, v2, ... according to the format string fmt. The return value is a bytes object encoding the values.\nustruct.pack_into(fmt, buffer, offset, v1, v2, ...)\nPack the values v1, v2, ... according to the format string fmt into a buffer starting at offset. offset may be negative to count from the end of buffer.\nustruct.unpack(fmt, data)\nUnpack from the data according to the format string fmt. The return value is a tuple of the unpacked values.\nustruct.unpack_from(fmt, data, offset=0)\nUnpack from the data starting at offset according to the format string fmt. offset may be negative to count from the end of buffer. The return value is a tuple of the unpacked values.\n"},"firmwareapi/micropython/_thread.html":{"url":"firmwareapi/micropython/_thread.html","title":"_thread","keywords":"","body":"_thread\nThis module provides low-level primitives for working with multiple threads (also called light-weight processes or tasks) — multiple threads of control sharing their global data space. For synchronisation, simple locks (also called mutexes or binary semaphores) are provided.\nWhen a thread specific error occurs a RuntimeError exception is raised.\nQuick Usage Example\nimport _thread\nimport time\n\ndef th_func(delay, id):\n while True:\n time.sleep(delay)\n print('Running thread %d' % id)\n\nfor i in range(2):\n _thread.start_new_thread(th_func, (i + 1, i))\n\nMethods\n_thread.start_new_thread(function, args[, kwargs])\nStart a new thread and return its identifier. The thread executes the function with the argument list args (which must be a tuple). The optional kwargs argument specifies a dictionary of keyword arguments. When the function returns, the thread silently exits. When the function terminates with an unhandled exception, a stack trace is printed and then the thread exits (but other threads continue to run).\n_thread.exit()\nRaise the SystemExit exception. When not caught, this will cause the thread to exit silently.\n_thread.allocate_lock()\nReturn a new lock object. Methods of locks are described below. The lock is initially unlocked.\n_thread.get_ident()\nReturn the thread identifier of the current thread. This is a nonzero integer. Its value has no direct meaning; it is intended as a magic cookie to be used e.g. to index a dictionary of thread-specific data. Thread identifiers may be recycled when a thread exits and another thread is created.\n_thread.stack_size([size])\nReturn the thread stack size (in bytes) used when creating new threads. The optional size argument specifies the stack size to be used for subsequently created threads, and must be 0 (use platform or configured default) or a positive integer value of at least 4096 (4KiB). 4KiB is currently the minimum supported stack size value to guarantee sufficient stack space for the interpreter itself.\nObjects\n_thread.LockType\nThis is the type of lock objects.\nclass Lock\nUsed for synchronisation between threads\nMethods\nLock objects have the following methods:\nlock.acquire(waitflag=1, timeout=-1)\nWithout any optional argument, this method acquires the lock unconditionally, if necessary waiting until it is released by another thread (only one thread at a time can acquire a lock — that's their reason for existence).\nIf the integer waitflag argument is present, the action depends on its value: if it is zero, the lock is only acquired if it can be acquired immediately without waiting, while if it is nonzero, the lock is acquired unconditionally as above.\nIf the floating-point timeout argument is present and positive, it specifies the maximum wait time in seconds before returning. A negative timeout argument specifies an unbounded wait. You cannot specify a timeout if waitflag is zero.\nThe return value is True if the lock is acquired successfully, False if not.\nlock.release()\nReleases the lock. The lock must have been acquired earlier, but not necessarily by the same thread.\nlock.locked()\nReturn the status of the lock: True if it has been acquired by some thread, False if not.\nIn addition to these methods, lock objects can also be used via the with statement, e.g.:\nimport _thread\n\na_lock = _thread.allocate_lock()\n\nwith a_lock:\n print(\"a_lock is locked while this executes\")\n\n"},"firmwareapi/micropython/builtin.html":{"url":"firmwareapi/micropython/builtin.html","title":"Builtin","keywords":"","body":"Builtin\nAll builtin functions are described here. They are also available via builtins module.\nabs()\nall()\nany()\nbin()\nclass bool\nclass bytearray\nclass bytes\ncallable()\nchr()\nclass method()\ncompile()\nclass complex\nclass dict\ndir()\ndivmod()\nenumerate()\neval()\nexec()\nfilter()\nclass float\nclass frozenset\ngetattr()\nglobals()\nhasattr()\nhash()\nhex()\nid()\ninput()\nclass int\nisinstance()\nissubclass()\niter()\nlen()\nclass list\nlocals()\nmap()\nmax()\nclass memoryview\nmin()\nnext()\nclass object\noct()\nopen()\nord()\npow()\nprint()\nproperty()\nrange()\nrepr()\nreversed()\nround()\nclass set\nsetattr()\nsorted()\nstaticmethod()\nclass str\nsum()\nsuper()\nclass tuple\ntype()\nzip()\n"},"firmwareapi/notes.html":{"url":"firmwareapi/notes.html","title":"Notes","keywords":"","body":"Notes\nInterrupt Handling\nIn Pycom's ESP32 MicroPython port there are no restrictions on what can be done within an interrupt handler. For example, other ports do not allow allocating memory inside the handler or the use of sockets.\nThese limitations were raised by handling the interrupt events differently. When an interrupt happens, a message is posted into a queue, notifying a separate thread that the appropriate callback handler should be called. Such handler would receive an argument. By default it is the object associated with the event.\nThe user can do whatever is required inside of the callback, such as creating new variables, or even sending network packets. Bear in mind that interrupts are processed sequentially and thus it is ideal to keep the handlers as short as possible in order to attend all of them in the minimum time.\nCurrently, there are 2 classes that support interrupts; the Alarm and Pin classes. Both classes provide the .callback() method that enables the interrupt and registers the given handler. For more details about interrupt usage along with examples, please visit their respective sections.\nCurrently the interrupt system can queue up to 16 interrupts.\n\n"},"datasheets/introduction.html":{"url":"datasheets/introduction.html","title":"Introduction","keywords":"","body":"Introduction\nThe follow pages contain all information relating to each product, for examples: pinouts, spec sheets, relevant examples and notes.\nDevelopment Modules\nOEM modules\nExpansion Boards and Shields\n"},"datasheets/development/":{"url":"datasheets/development/","title":"Development Modules","keywords":"","body":"Development Modules\nThis section contains all of the datasheets for the Pycom Development Devices. This includes the WiPy 2.0 and 3.0, LoPy, LoPy 4, SiPy, GPy, and FiPy.\n"},"datasheets/development/wipy2.html":{"url":"datasheets/development/wipy2.html","title":"WiPy 2.0","keywords":"","body":"WiPy 2.0\n**** **\nStore: Discontinued, See WiPy3\nGetting Started: Click Here\nDatasheet\nThe datasheet of the WiPy2 is available as a PDF File.\nWiPy 2 Datasheet\nPinout\nThe pinout of the WiPy2 is available as a PDF File.\nWiPy 2 Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the WiPy2 will create a WiFi access point with the SSID wipy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nPower\nThe Vin pin on the WiPy2 can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the WiPy2, otherwise the on-board regulator will be damaged.\nDeep Sleep\nDue to a couple issues with the WiPy2 design the module draws more current than it should while in deep sleep. The DC-DC switching regulator always stays in high performance mode which is used to provide the lowest possible output ripple when the modules is in use. In this mode, it draws a quiescent current of 10mA. When the regulator is put into ECO mode, the quiescent current goes down to 10uA. Unfortunately, the pin used to control this mode is out of the RTC domain, and therefore not usable during deep sleep. This causes the regulator to always stay in PWM mode, keeping its quiescent current at 10mA. Alongside this the flash chip doesn't enter power down mode because the CS pin is floating during deep sleep. This causes the flash chip to consume around 2mA of current. To work around this issue a \"deep sleep shield\" is available that attaches to the module and allows power to be cut off from the device. The device can then be re-enabled either on a timer or via pin interrupt. With the deep sleep shield the current consumption during deep sleep is between 7uA and 10uA depending on the wake sources configured.\nTutorials\nTutorials on how to the WiPy2 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the WiPy2:\n\nWiFi connection\nBLE\n\n"},"datasheets/development/wipy3.html":{"url":"datasheets/development/wipy3.html","title":"WiPy 3.0","keywords":"","body":"WiPy 3.0\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the WiPy3 is available as a PDF File.\nWiPy3 Datasheet\nPinout\nThe pinout of the WiPy3 is available as a PDF File.\nWiPy3 Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nDifferences from WiPy 2.0\n\nDeep sleep current draw fixed, now only 19.7µA\nUpgraded RAM from 512KB to 4MB\nUpgraded External FLASH from 4MB to 8MB\nAntenna select pin moved from GPIO16 to GPIO21 (P12)\n\nNotes\nWiFi\nBy default, upon boot the WiPy3 will create a WiFi access point with the SSID wipy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nThe RF switch that selects between the on-board and external antenna is connected to P12, for this reason using P12 should be avoided unless WiFi is disabled in your application.\nPower\nThe Vin pin on the WiPy3 can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the WiPy3, otherwise the on-board regulator will be damaged.\nTutorials\nTutorials on how to the WiPy3 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the WiPy3:\n\nWiFi connection\nBLE\n\n"},"datasheets/development/lopy.html":{"url":"datasheets/development/lopy.html","title":"LoPy","keywords":"","body":"LoPy\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the LoPy is available as a PDF File.\nLoPy Datasheet\nPinout\nThe pinout of the LoPy is available as a PDF File\nLoPy Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the LoPy will create a WiFi access point with the SSID lopy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nPower\nThe Vin pin on the LoPy can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the LoPy, otherwise the on-board regulator will be damaged.\nDeep Sleep\nDue to a couple issues with the LoPy design the module draws more current than it should while in deep sleep. The DC-DC switching regulator always stays in high performance mode which is used to provide the lowest possible output ripple when the modules is in use. In this mode, it draws a quiescent current of 10mA. When the regulator is put into ECO mode, the quiescent current goes down to 10uA. Unfortunately, the pin used to control this mode is out of the RTC domain, and therefore not usable during deep sleep. This causes the regulator to always stay in PWM mode, keeping its quiescent current at 10mA. Alongside this the flash chip doesn't enter power down mode because the CS pin is floating during deep sleep. This causes the flash chip to consume around 2mA of current. To work around this issue a \"deep sleep shield\" is available that attaches to the module and allows power to be cut off from the device. The device can then be re-enabled either on a timer or via pin interrupt. With the deep sleep shield the current consumption during deep sleep is between 7uA and 10uA depending on the wake sources configured.\nTutorials\nTutorials on how to the LoPy module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the LoPy:\n\nWiFi connection\nLoRaWAN node\nLoRaWAN nano gateway\nBLE\n\n"},"datasheets/development/lopy4.html":{"url":"datasheets/development/lopy4.html","title":"LoPy 4","keywords":"","body":"LoPy 4\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the LoPy4 is available as a PDF File.\nLoPy4 Datasheet\nPinout\nThe pinout of the LoPy4 is available as a PDF File\nLoPy4 Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the LoPy4 will create a WiFi access point with the SSID lopy4-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nThe RF switch that selects between the on-board and external antenna is connected to P12, for this reason using P12 should be avoided unless WiFi is disabled in your application.\nPower\nThe Vin pin on the LoPy4 can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the LoPy4, otherwise the on-board regulator will be damaged.\nTutorials\nTutorials on how to the LoPy4 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the LoPy4:\n\nWiFi connection\nLoRaWAN node\nLoRaWAN nano gateway\nSigfox\nBLE\n\n"},"datasheets/development/sipy.html":{"url":"datasheets/development/sipy.html","title":"SiPy","keywords":"","body":"SiPy\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the SiPy is available as a PDF File.\nSiPy Datasheet\nPinout\nThe pinout of the SiPy is available as a PDF File\nSiPy Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the SiPy will create a WiFi access point with the SSID sipy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nPower\nThe Vin pin on the SiPy can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the SiPy, otherwise the on-board regulator will be damaged.\nDeep Sleep\nDue to a couple issues with the SiPy design the module draws more current than it should while in deep sleep. The DC-DC switching regulator always stays in high performance mode which is used to provide the lowest possible output ripple when the modules is in use. In this mode, it draws a quiescent current of 10mA. When the regulator is put into ECO mode, the quiescent current goes down to 10uA. Unfortunately, the pin used to control this mode is out of the RTC domain, and therefore not usable during deep sleep. This causes the regulator to always stay in PWM mode, keeping its quiescent current at 10mA. Alongside this the flash chip doesn't enter power down mode because the CS pin is floating during deep sleep. This causes the flash chip to consume around 2mA of current. To work around this issue a \"deep sleep shield\" is available that attaches to the module and allows power to be cut off from the device. The device can then be re-enabled either on a timer or via pin interrupt. With the deep sleep shield the current consumption during deep sleep is between 7uA and 10uA depending on the wake sources configured.\nTutorials\nTutorials on how to the SiPy module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the SiPy:\n\nWiFi connection\nSigfox\nBLE\n\n"},"datasheets/development/gpy.html":{"url":"datasheets/development/gpy.html","title":"GPy","keywords":"","body":"GPy\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the GPy is available as a PDF File.\nGPy Datasheet\nThe drawing of the LTE-M antenna is available as a PDF File.\nLTE-M Antenna Drawing\nPinout\nThe pinout of the GPy is available as a PDF File\nGPy Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the GPy will create a WiFi access point with the SSID gpy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nThe RF switch that selects between the on-board and external antenna is connected to P12, for this reason using P12 should be avoided unless WiFi is disabled in your application.\nPower\nThe Vin pin on the GPy can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the GPy, otherwise the on-board regulator will be damaged.\nAT Commands\nThe AT commands for the Sequans Monarch modem on the GPy are available in a PDF file.\nAT Commands for Sequans\nTutorials\nTutorials on how to the GPy module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the GPy:\n\nWiFi connection\nLTE CAT-M1\nNB-IoT\nBLE\n\n"},"datasheets/development/fipy.html":{"url":"datasheets/development/fipy.html","title":"FiPy","keywords":"","body":"FiPy\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the FiPy is available as a PDF File.\nFiPy Datasheet\nThe drawing of the LTE-M antenna is available as a PDF File.\nLTE-M Antenna Drawing\nPinout\nThe pinout of the FiPy is available as a PDF File\nFiPy Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the FiPy will create a WiFi access point with the SSID fipy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nThe RF switch that selects between the on-board and external antenna is connected to P12, for this reason using P12 should be avoided unless WiFi is disabled in your application.\nPower\nThe Vin pin on the FiPy can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the FiPy, otherwise the on-board regulator will be damaged.\nAT Commands\nThe AT commands for the Sequans Monarch modem on the FiPy are available in a PDF file.\nAT Commands for Sequans\nTutorials\nTutorials on how to the FiPy module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the FiPy:\n\nWiFi connection\nLoRaWAN node\nLoRaWAN nano gateway\nSigfox\nLTE CAT-M1\nNB-IoT\nBLE\n\n"},"datasheets/oem/":{"url":"datasheets/oem/","title":"OEM Modules","keywords":"","body":"OEM Modules\nThis section contains all of the datasheets for the Pycom OEM Devices. This includes the W01, L01, L04, and G01.\n"},"datasheets/oem/w01.html":{"url":"datasheets/oem/w01.html","title":"W01","keywords":"","body":"W01\n\nDatasheet\nThe datasheet of the W01 is available as a PDF File.\nW01 Datasheet\nPinout\nThe pinout of the W01 is available as a PDF File\nW01 Pinout\n\nDrawings\nThe drawings for the W01 is available as a PDF File.\nW01 Drawings\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nTutorials\nTutorials on how to the W01 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the W01:\n\nWiFi connection\nBLE\n\n"},"datasheets/oem/l01.html":{"url":"datasheets/oem/l01.html","title":"L01","keywords":"","body":"L01\n \nDatasheet\nThe datasheet of the L01 is available as a PDF File.\nL01 Datasheet\nPinout\nThe pinout of the L01 is available as a PDF File\nL01 Pinout\n\nDrawings\nThe drawings for the L01 is available as a PDF File.\nL01 Drawing\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nTutorials\nTutorials on how to the L01 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the L01:\n\nWiFi connection\nLoRaWAN node\nLoRaWAN nano gateway\nBLE\n\n"},"datasheets/oem/l04.html":{"url":"datasheets/oem/l04.html","title":"L04","keywords":"","body":"L04\n \nDatasheet\nThe datasheet of the L04 is available as a PDF File.\nL04 Datasheet\nPinout\nThe pinout of the L04 is available as a PDF File\nL04 Pinout\n\nDrawings\nThe drawings for the L04 is available as a PDF File.\nL04 Drawings\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nTutorials\nTutorials on how to the L04 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the L04:\n\nWiFi connection\nLoRaWAN node\nLoRaWAN nano gateway\nSigfox\nBLE\n\n"},"datasheets/oem/g01.html":{"url":"datasheets/oem/g01.html","title":"G01","keywords":"","body":"G01\n\nDatasheet\nThe datasheet of the G01 is available as a PDF File.\nG01 Datasheet\nPinout\nThe pinout of the G01 is available as a PDF File\nG01 Pinout\n\nDrawings\nThe drawings for the G01 is available as a PDF File.\nG01 Drawings\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nAT Commands\nThe AT commands for the Sequans Monarch modem on the G01 are available in a PDF file.\nAT Commands for Sequans\nTutorials\nTutorials on how to the G01 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the G01:\n\nWiFi connection\nLTE CAT-M1\nNB-IoT\nBLE\n\n"},"datasheets/oem/l01_reference.html":{"url":"datasheets/oem/l01_reference.html","title":"L01 OEM Baseboard Reference","keywords":"","body":"L01 OEM Baseboard Reference\n\nThe L01 OEM reference board is a reference design suitable L01 as well as W01 making it possible to have a single PCB design that can accommodate both OEM modules.\nIf you require a reference board for the L04 or G01, this design is not suitable as it does not feature a SIM slot or the double antenna connection. For the G01 or L04 please use the Universal OEM Baseboard Reference\n\nFeatures\n\nSuits both L01 or W01 OEM Modules\nU.FL connector for the L01's LoRa output.\nOn-board 2.4GHz antenna for WiFi and Bluetooth, with the ability to switch\nto a external antenna via a U.FL connector.\n\nWS2812B RGB LED\n\n3.5-5.5 Input switch mode DC-DC regulator with low current draw during deep\nsleep\n\nReset button\n\n\nLayout\nThe layout of the L01 baseboard reference is available as a PDF File\nL01 OEM Layout/gitbook/assets/l01-oem-layout.pdf)\n\nSchematic\nThe schematic of the L01 baseboard reference is available as a PDF File.\nL01 OEM Schematic\nAltium Project and Gerber Files\nThe Altium Project and Gerber files are also available as a ZIP File.\nL01 OEM Altium Project and Gerber Files\n"},"datasheets/oem/universal_reference.html":{"url":"datasheets/oem/universal_reference.html","title":"Universal OEM Baseboard Reference","keywords":"","body":"Universal OEM Baseboard Reference\n\nThe universal OEM reference board is a reference design suitable W01, L01, L04 and G01 OEM modules, making it possible to have a single PCB design that can accommodate all our OEM modules.\nIf you require a reference board for the G01, only this design is suitable. The L01 reference board does not contain the necessary SIM slot.\n\nFeatures\n\nSuits all OEM modules (L01, L04, W01, G01)\nOn-board 2.4GHz antenna for WiFi and Bluetooth, with the ability to switch\nto a external antenna via a U.FL connector.\n\n3 U.FL connectors for all the outputs available on the OEM modules\n\nWS2812B RGB LED\n3.5-5.5 Input switch mode DC-DC regulator with low current draw during deep\nsleep\n\nReset button\n\n\nLayout\nThe layout of the OEM baseboard reference is available as a PDF File\nOEM Layout\n\nSchematic\nThe schematic of the OEM baseboard reference is available as a PDF File.\nOEM Schematic\nAltium Project and Gerber Files\nThe Altium Project and Gerber files are also available as a ZIP File.\nOEM Altium Project and Gerber Files\n"},"datasheets/boards/":{"url":"datasheets/boards/","title":"Expansion Boards and Shields","keywords":"","body":"Expansion Boards and Shields\nThis section contains all of the datasheets for the Pycom Expansion Boards and Shields. This includes the Expansion Board, Pytrack, Pysense and Deep Sleep Shield.\n"},"datasheets/boards/expansion3.html":{"url":"datasheets/boards/expansion3.html","title":"Expansion Board 3.0","keywords":"","body":"Expansion Board 3.0\n\nDatasheet\nThe datasheet of the Expansion Board is available as a PDF File.\nOEM Altium Project and Gerber Files\nPinout\nThe pinout of the Expansion Board is available as a PDF File\nExpansion Board 3 Pinout\n\nBe gentle when plugging/unplugging from the USB connector. Whilst the USB connector is soldered and is relatively strong, if it breaks off it can be very difficult to fix.\n\nBattery Charger\nThe Expansion Board features a single cell Li-Ion/Li-Po charger. When the board is being powered via the micro USB connector, the Expansion Board will charge the battery (if connected). When the CHG jumper is present the battery will be charged at 450mA. If this value is too high for your application, removing the jumper lowers the charge current to 100mA.\nTo use the battery, pull P8/G15 high (connect to 3v3). If you want to use the SD card as well, use a 10k pull-up.\n\nDifferences between v2.0 and v3.0\n\nThe FTDI chip as been replaced with a custom programmed PIC like on the\nPysense/Pytrack/Pyscan boards. This allows our firmware update tool to\nautomatically put the module into bootloader mode.\n\nAdded a \"Safe boot\" button to enter safe boot easier. This button connects\nP12 to 3.3v and if pressed and held while the reset button is pressed on\na Pycom module, the module will enter safe boot.\n\n\nTroubleshooting\n\nIf PIC stays in bootloader mode, the dfu-util update should be performed\n\n"},"datasheets/boards/pytrack.html":{"url":"datasheets/boards/pytrack.html","title":"Pytrack","keywords":"","body":"Pytrack\n \nDatasheet\nThe datasheet of the Pytrack is available as a PDF File.\nPytrack Datasheet\nPinout\nThe pinout of the Pytrack is available as a PDF File\nPytrack Pinout\n\nBattery Charger\nThe board features a single cell Li-Ion/Li-Po charger. When the board is being powered via the micro USB connector, it will charge the battery (if connected).\n"},"datasheets/boards/pysense.html":{"url":"datasheets/boards/pysense.html","title":"Pysense","keywords":"","body":"Pysense\n \nDatasheet\nThe datasheet of the Pysense is available as a PDF File.\nPysense Datasheet\nPinout\nThe pinout of the Pysense is available as a PDF File\nPysense Pinout\n\nBattery Charger\nThe board features a single cell Li-Ion/Li-Po charger. When the board is being powered via the micro USB connector, it will charge the battery (if connected).\n"},"datasheets/boards/pyscan.html":{"url":"datasheets/boards/pyscan.html","title":"Pyscan","keywords":"","body":"Pyscan\n \nDatasheet\nThe datasheet of the Pyscan is available as a PDF File.\nPyscan Datasheet\nPyscan Libraries\n\nPyscan libraries to use the RFID/NFC reader are located here\nThe accelerometer library is here\n\nFor the time being, we recommend to upload the MFRC630.mpy file via FTP due to current limitations of Pymakr that will be fixed shortly.\n\nLibraries for the rest of the components will be added soon.\nPyscan components:\n\nAccelerometer: ST LIS2HH12\nAmbient light sensor: Lite-on LTR-329ALS-01\nRFID/NFC reader: NXP MFRC63002HN, 151\n\nDriver\nThe Windows 7 driver for Pyscan is located here.\nFor other Operating Systems there's no driver required.\nPinout\nThe pinout of the Pyscan is available as a PDF File\nPyscan Pinout\n\nBattery Charger\nThe board features a single cell Li-Ion/Li-Po charger. When the board is being powered via the micro USB connector, it will charge the battery (if connected).\n"},"datasheets/boards/expansion2.html":{"url":"datasheets/boards/expansion2.html","title":"Expansion Board 2.0","keywords":"","body":"Expansion Board 2.0\n \nDatasheet\nThe datasheet of the Expansion Board is available as a PDF File.\nExpansion Board 2 Datasheet\nPinout\nThe pinout of the Expansion Board is available as a PDF File\nExpansion Board 2 Pinout\n\nBe gentle when plugging/unplugging from the USB connector. Whilst the USB connector is soldered and is relatively strong, if it breaks off it can be very difficult to fix.\n\nBattery Charger\nThe Expansion Board features a single cell Li-Ion/Li-Po charger. When the board is being powered via the micro USB connector, the Expansion Board will charge the battery (if connected). When the CHG jumper is present the battery will be charged at 450mA. If this value is too high for your application, removing the jumper lowers the charge current to 100mA.\n"},"datasheets/boards/deepsleep/":{"url":"datasheets/boards/deepsleep/","title":"Deep Sleep Shield","keywords":"","body":"Deep Sleep Shield\nThe schematic of the Deep Sleep Shield is available as a PDF File.\nDeep Sleep Schematic\nPinout\nThe pinout of the Deep Sleep Shield is available as a PDF File\nDeep Sleep Pinout\n\nTo correctly connect a WiPy 2.0, LoPy or SiPy to the Deep Sleep Shield, align the white triangle on the Shield with the LED of the Pycom Device. Once the Pycom Device is seated onto the Deep Sleep Shield, this can then be connected to the Expansion Board\n\n\n"},"datasheets/boards/deepsleep/api.html":{"url":"datasheets/boards/deepsleep/api.html","title":"Deep Sleep API","keywords":"","body":"Deep Sleep API\nThis chapter describes the library which controls the Deep Sleep Shield. This includes the controls for external interrupts and timer setup of the deep sleep functionality.\nTo use this library, please upload the associated Deep Sleep Library to /lib on the target Pycom device.\nQuick Example\nfrom deepsleep import DeepSleep\nimport deepsleep\n\nds = DeepSleep()\n\n# get the wake reason and the value of the pins during wake up\nwake_s = ds.get_wake_status()\nprint(wake_s)\n\nif wake_s['wake'] == deepsleep.PIN_WAKE:\n print(\"Pin wake up\")\nelif wake_s['wake'] == deepsleep.TIMER_WAKE:\n print(\"Timer wake up\")\nelse: # deepsleep.POWER_ON_WAKE:\n print(\"Power ON reset\")\n\nds.enable_pullups('P17') # can also do ds.enable_pullups(['P17', 'P18'])\nds.enable_wake_on_fall('P17') # can also do ds.enable_wake_on_fall(['P17', 'P18'])\n\nds.go_to_sleep(60) # go to sleep for 60 seconds\n\nDeepSleep\nThe Deep Sleep Shield allows for waking up via a user trigger and also via an external interrupt (i.e. Accelerometer, Button).\nConstructors\nclass DeepSleep()\nCreates a DeepSleep object, that will control the board's sleep features. For example;\nds = DeepSleep()\n\nMethods\ndeepsleep.enable_auto_poweroff()\nThis method allows for a critical battery voltage to be set. For example, if the external power source (e.g. LiPo Cell) falls below 3.3V, turn off the Pycom device. This is intended to protect the hardware from under voltage.\ndeepsleep.enable_pullups(pins)\nThis method allows for pull-up pins to be enabled. For example, if an external trigger occurs, wake the Pycom device from Deep Sleep. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.disable_pullups(pins)\nThis method allows for pull-up pins to be disabled. For example, if an external trigger occurs, wake the Pycom device from Deep Sleep. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.enable_wake_on_raise(pins)\nThis method allows for pull-up pins to trigger on a rising voltage. For example, if an external rising voltage triggers occurs, wake the Pycom device from Deep Sleep. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.disable_wake_on_raise(pins)\nThis method allows for disabling pull-up pins that trigger on a rising voltage. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.enable_wake_on_fall(pins)\nThis method allows for pull-up pins to trigger on a falling voltage. For example, if an external falling voltage triggers occurs, wake the Pycom device from Deep Sleep. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.disable_wake_on_fall(pins)\nThis method allows for disabling pull-up pins that trigger on a falling voltage. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.get_wake_status()\nThis method returns the status of the pins at wakeup from deep sleep. The method returns a dict with the states of wake, P10, P17, P18.\ndeepsleep.set_min_voltage_limit(value)\nThis method relates to the enable_auto_poweroff method and allows the user to specify the minimum power off voltage as a value.\ndeepsleep.go_to_sleep(seconds)\nThis method sends the board into deep sleep for a period of seconds or until an external interrupt has triggered (see set_pullups).\ndeepsleep.hw_reset()\nThis method resets the PIC controller and resets it to the state previous to the pins/min-voltage being set.\nPlease note that more functionality is being added weekly to these libraries. If a required feature is not available, feel free to contribute with a pull request at the Pycom Libraries GitHub repository.\n\n"},"datasheets/notes.html":{"url":"datasheets/notes.html","title":"Notes","keywords":"","body":"Notes\nPowering with an external power source\nThe devices can be powered by a battery or other external power source.\nBe sure to connect the positive lead of the power supply to VIN, and ground to GND.\nWhen powering via VIN:\n\nThe input voltage must be between 3.4V and 5.5V.\n\nPlease DO NOT power the board via the 3.3V pin as this may damage the device. ONLY use the VIN pin for powering Pycom devices.\n\nThe battery connector for the Expansion Board is a JST PHR-2 variant. The Expansion Board exposes the male connector and an external battery should use a female adapter in order to connect and power the expansion board. The polarity of the battery should be checked before being plugged into the expansion board, the cables may require swapping.\nThe GPIO pins of the modules are NOT 5V tolerant, connecting them to voltages higher than 3.3V might cause irreparable damage to the device.\n\nStatic electricity can damage components on the device and may destroy them. If there is a lot of static electricity in the area (e.g. dry and cold climates), take extra care not to shock the device. If the device came in a ESD bag (Silver packaging), the best way to store and carry the device is inside this bag as it will be protected against static discharges.\n\n"},"pybytes/introduction.html":{"url":"pybytes/introduction.html","title":"Introduction","keywords":"","body":"Introduction\n\nWhat is Pybytes?\nPybytes is an IoT Ecosystem that empowers you by granting full control of all your Pycom devices.\nWith Pybytes you have control over your device's data stream and more:\n\nVisualise sensors data according to your interests using our customisable dashboard;\nCheck the status of your entire fleet;\nKeep track of your assets with our geolocation feature;\nDistribute firmware updates on a scalable approach.\n\nIn a nutshell, Pybytes is an environment designed to optimise your IoT applications using Pycom boards.\nWhat Pybytes offers you?\n\nData Visualisation: Pybytes dashboard is customisable, allowing you to freely set up key performance indicators and time series data from all your sensors.\nIntelligent notifications: Keep track of your device's status, battery level, data streaming and measurements with pre-defined alarms. Receive notifications via email or SMS.\nTerminal: Execute commands to gather accurate information from your devices using Pybytes terminal shell.\nFirmware updates over the air: Upgrade or downgrade firmware versions with our exclusive firmware update.\nTrack your assets position: Google Maps API empowers your view over your device's geolocation.\n\nLet's get started!\n\nGetting started with Pybytes\nConnect your Pycom module to Pybytes\nVisualise data from your device\n​Integrations with external services​\n\n"},"pybytes/getstarted.html":{"url":"pybytes/getstarted.html","title":"Getting Started with Pybytes","keywords":"","body":"Getting Started with Pybytes\nFollow these steps to create a Pybytes account:\nStep 1: Go to the registration page\n\nGo to this link.\nEnter your full name, email address and a password to your account.\nConfirm the verification message sent to your email address.\nClick on the link and complete your login.\n\nGo Invent!\nNow it's time to explore Pybytes. You can start by connecting your Pycom board to Pybytes.\n"},"pybytes/connect/":{"url":"pybytes/connect/","title":"Add a device to Pybytes","keywords":"","body":"Add a device to Pybytes\nIn this section, we will explain to you how to add a device to Pybytes\nStep 1: Add device wizard\nIn Pybytes, go to Devices Page:\n\nClick on Add Device.\n\n\n\nSelect your device (e.g., WiPy, LoPy, SiPy, etc.);\n\n\n\nSelect your shield (e.g., PySense, PyTrack, PyScan or other);\n\n\n\nSelect your network option;\n\n\n\nEnter a unique name and the network credentials (SSID and password) for your device;\n\n\nStep 2: Connect your device to Pybytes\nAt the end of the \"Add Device\" wizard, Pybytes will give you two options for you to connect your device to Pybytes:\n\nSelect how you would like to connect your device to Pybytes:\n\nConnect your device quickly (Recommended)\n\n\nConnect your device by flashing Pybytes Library\n\nFrom firmware 1.16.x onwards all Pycom devices come with Pybytes library built-in /frozen folder. That means that you can choose between adding your device quickly with the firmware updater or you can flash Pybytes library manually.\n\n"},"pybytes/connect/quick.html":{"url":"pybytes/connect/quick.html","title":"Connect to Pybytes: Quick Add","keywords":"","body":"Connect to Pybytes: Quick Add\nConnecting a device to Pybytes quickly by using the Firmware Updater\nIn this section, we explain to you how to connect your device to Pybytes quickly using the Firmware Updater.\nIn case you want to extend Pybytes library you can flash Pybytes library manually. Click here for more information.\n\nStep 1: Download the firmware updater\nAt the last step of the \"Add Device\" process:\n\n\nDownload the firmware updater for your operating system;\n\n\n\nCopy the device token.\n\nStep 2: Firmware updater\nInstall the Firmware updater on your computer.\n\nStart the Firmware updater;\n\n\n\n\nSelect your device serial port (Make sure your device is connected to your computer);\n\nMark the options \"Erase flash file system\" and \"Force update Pybytes registration\";\n\n\n\n\nPaste your device token from Pybytes;\n\n\n\nThe firmware updater will update the device's firmware.\n\n\n\nNext step: Set up your device's dashboard!\nNow it's time to display data from your device into Pybytes dashboard.\n"},"pybytes/connect/flash.html":{"url":"pybytes/connect/flash.html","title":"Connect to Pybytes: Flash Pybytes library manually","keywords":"","body":"Connect to Pybytes: Flash Pybytes library manually\nConnecting a device to Pybytes by flashing Pybytes library manually\nIn this section, we will explain to you how to connect your device to Pybytes by flashing Pybytes library manually.\nFrom firmware 1.16.x onwards all Pycom devices come with Pybytes library build-in /frozen folder. That means that you can add your device quickly without the need of flashing Pybytes library manually. Click here for more information.\n\nStep 1: Download your Pybytes Library\nAt the last step of the \"Add Device\" process:\n\n\nClick on download \"Pybytes library\"\n\n\nYou can also download Pybytes library at the device's settings page:\n\nNavigate to your device in Pybytes;\n\nOn your device's page click on settings tab;\n\nClick on the button Download at Pybytes library;\n\n\n\nStep 2. Flash your device with Pymakr\nIn case you haven't installed Pymakr plugin, follow these instructions.\n\n\nConnect your device to your computer with USB cable.\nExtract download Pybytes library and open extracted folder with Atom.\nGet your device serial port: in Pymakr plugin click on More > get serial ports\nPaste your device's serial port to pymakr.conf file:\n {\n \"address\": \"PASTE_YOUR_SERIAL_PORT_HERE\",\n \"username\": \"micro\",\n \"password\": \"python\",\n \"sync_folder\": \"flash\"\n }\n\n\nCheckout your flash/pybytes_config.json file. It will be pre-filled with your information from Pybytes\nLike deviceToken or WiFi credentials. You can change e.g. your WiFy password here.\n\nPut your device in safe boot mode.\n\nUpload code to your device by clicking on Upload button in Pymakr.\nAfter all Pybytes library files are uploaded to device, device will restart and will connect to Pybytes.\n\n\nPybytes library is written to /flash folder and will take precedence over build in firmware libraries in /frozen folder.\n\nNext step: Set up your device's dashboard!\nNow it's time to display data from your device into Pybytes dashboard.\n"},"pybytes/connect/sigfox/":{"url":"pybytes/connect/sigfox/","title":"Add Sigfox device","keywords":"","body":"Add Sigfox device\nBefore you start you need to create Sigfox account. You need Pycom device with Sigfox to get your Sigfox account. Follow these instructions.\n\nCreate Sigfox API credentials\nOnce you have you account setup and are logged in Sigfox backend, you need to create API credentials for Pybytes.\nClick on GROUP → → API ACCESS → New\n\nIn the form chose arbitrary name, select Profiles DEVICE MANAGER [R] and DEVICE MANAGER [W]. Then click on Ok.\n\nCopy Login and Password to the clipboard.\n\nIn Pybytes go to Settings → Sigfox API or follow this link then paste in the form.\n\nSigfox contract types\nSigfox DevKit contracts\nRead more how to use Sigfox with devKit contract.\nSigfox custom contracts\nRead more how to use Sigfox with Custom contract.\n"},"pybytes/connect/sigfox/devkit.html":{"url":"pybytes/connect/sigfox/devkit.html","title":"DevKit contract","keywords":"","body":"DevKit contract\nEvery Sigfox Pycom device comes with free Sigfox connectivity - Sigfox DevKit contract. It provides one year of Sigfox connectivity. This is great for prototyping.\nBut every device you want to add to Pybytes you need register on Sigfox backend. You need to repeat Sigfox activation procedure.\nAfter you add your Sigfox credentials to Pybytes you can see DevKit contract type is selected as default (on page Settings → Sigfox API).\n\nAdd your device to Pybytes\n\nCreate Sigfox device (Lopy4, SiPy, FiPy) in Pybytes and copy its device token to clipboard.\nConnect your device to your computer and update it with Pycom firmware updater.\nSelect Pybytes firmware\nPaste your device token to firmware updater\n\n\n\nDetailed steps which are same for all devices are described here.\n\nCheck sigfox status\nGo to: Devices → → configuration\nNow you should see sigfox status component.\nClick on Check Sigfox status button\n\nYou should see two green lights.\nFirst green light means that your device was found in Sigfox group which uses Sigfox API credentials you saved to Pybytes.\nSecond green light means that HTTP POST callback was created on Sigfox backend for your Dev Kit device type. Because Dev Kit device type is associated with Dev Kit contract (which can hold only one device), you need to create Sigfox callback for every device you add to Pybytes.\nNote that Sigfox callback are associated to Sigfox device types.\nThis is not an issue with Custom contract, where device type on Sigfox backend can contain many devices, therefore you just need to one Sigfox HTTP POST callback (It is created automatically by Pybytes).\nTroubleshooting\nDisengage Sigfox sequence number\n"},"pybytes/connect/sigfox/custom.html":{"url":"pybytes/connect/sigfox/custom.html","title":"Custom contract","keywords":"","body":"Custom contract\nFor building Sigfox application on Pybytes we recommend to buy Sigfox contract.\nWith Sigfox custom contract you can use Pybytes to register Sigfox devices on Sigfox backend automatically (Pybytes talk to Sigfox backend API to register Sigfox devices automatically).\nYou can select Sigfox device type associated with your Sigfox custom contract.\nNewly created devices will be added to selected device type completely by Pybytes.\nAdding devices using Sigfox custom contract\nGo to: Settings (in sidebar) → Sigfox API → Settings\nand select Sigfox device type which is associated with Sigfox custom contract.\n\nAdd your Sigfox device to Pybytes\n\nCreate Sigfox device (Lopy4, SiPy, FiPy) in Pybytes and copy its device token to clipboard.\nConnect your device to your computer and update it with Pycom firmware updater.\nSelect Pybytes firmware\nPaste your device token to firmware updater\n\n\n\nDetailed steps which are same for all devices are described here.\n\nAfter your device was flashed with Pybytes firmware in automatically start adding itself to Sigfox backend.\n\nTroubleshooting\nDisengage Sigfox sequence number\n"},"pybytes/dashboard.html":{"url":"pybytes/dashboard.html","title":"Visualise data from your device","keywords":"","body":"Visualise data from your device\nIn this section, we will explain to you how to create widgets for data visualisation and set up your device's dashboard on Pybytes.\nWe assume that you already have your device connected to Pybytes. In case you haven't, check how to add your device here. After your done with that, you can proceed to the next example.\n\nStep 1: Set up your application (main.py)\nThe first step is to have an application running on your device. The application in this example sends data from a vector every 10 seconds to Pybytes.\n\nOpen the main.py file on Pymakr;\nInsert the following code on your main.py;\n\n# Import what is necessary to create a thread\nimport _thread\nfrom time import sleep\n\n# Increment index used to scan each point from vector sensors_data\ndef inc(index, vector):\n if index \n\nUpload the code into your device. Now your device is sending data to Pybytes.\n\nIn this code, we're calling the function pybytes.send_virtual_pin_value(persistent, pin, value)) to communicate with Pybytes. This function is part of the Pybytes library, and it has three arguments: persistent, pin and value.\n\npersistent denotes information that is infrequently accessed and not likely to be modified;\npin represents which virtual pin is receiving data;\nvalue is the value being attributed to that particular pin\n\n\nStep 2: Add a signal from your device\nGo to Pybytes.\n\nOn Devices page select a device;\n\n\n\nOn your device's page click on Data tab.\n\n\n\nClick on the Define New Signal button.\n\n\n\nDefine the new signal by entering a number, a name, a data type and a unit. Finally, click on the button Define.\n\n\n\nYour signal was added!\n\n\nThe name and unit are labels used to identify your signal inside Pybytes (In this example we defined Sinwave as the name of the signal and Rad as the unit).\nThe signal number has to match the pin number that you defined on pybytes.send_virtual_pin_value function call, inside your main.py code (In this example we defined pin = 1);\nThe datatype also has to match the variable used as argument on pybytes.send_virtual_pin_value function call, inside your main.py code (In this example our variable is a floating number; therefore we defined as a Float32).\n\nStep 3: Add a widget for the signal\n\nClick on the signal card.\n\n\n\nClick on the button Create a new display.\n\n\n\nSelect the type of visualisation (e.g. Bar chart or Line chart).\n\n\n\nYou can adjust the parameters of your widget at Settings. After, click on the button Create.\n\n\n\nYour widget was created. Now, add your widget to your device's dashboard. Click on the button Edit on your widget.\n\n\n\nMark the checkbox Display on Dashboard at Settings. Finally, click on the button Save.\n\n\n\nClick on the tab Dashboard. Your widget was successfully added there!\n\n\nStep 4: Organise your dashboard\n\nClick on the button Organise. Now the dashboard's grid will enter the edit mode and allow you to resize and reposition its widgets.\n\n\n\nResize a widget by clicking on the triangle icon at the bottom right corner of the widget and drag the cursor over the grid. After, click on the button Save to save this action.\n\n\n\nChange the widget's position by drag-and-dropping it over the grid. After, click on the button Save to save this action.\n\n\nDone!\nNow you've learned how to set up your device's dashboard to display data. Also, you can add more widgets to other pins of your device.\n"},"pybytes/integrations/":{"url":"pybytes/integrations/","title":"Integrations","keywords":"","body":"Integrations\nIntegration with external services \nPybytes offers a way to interact with external IoT platform or custom services, like the following:\n\n​AWS IoT: a managed cloud platform that lets connected devices easily and securely interact with cloud applications and other devices\n\n"},"pybytes/integrations/amazon-iot.html":{"url":"pybytes/integrations/amazon-iot.html","title":"Amazon IoT","keywords":"","body":"Amazon IoT\nWhenever one of your integrated devices sends a message to our broker, we republish the binary payload to the endpoint specified for its integration.\nIntegrate your devices \n\nGo in the sidebar, click on New Integration and then on Amazon Web Services\n\n\n\nFill in the form choosing an AWS region and your AWS credentials. You can optionally choose to save them inside the local storage for future use. Once you're done, click Login\n\n\n\nIn this step, you have to specify the AWS group name (just alphanumeric letter, dashes and underscore are allowed), the custom topic and the devices you want to bind to AWS. When you're ready, click Create\n\n\n\nIf everything's worked as expected, you should be able to see a summary of your integration like the following:\n\n\n\nThe corresponding AWS Thing and AWS Group has been created as well, you just have to log in to the console and choose the same region of your devices from the topbar. You'll be able to explore groups and things' details.\n\n\n\nThe device's name is specified as an attribute of the thing.\n\n\nFinal considerations \nIn order to save the data received by AWS, you must set up a rule. You can also test that everything's working with the AWS IoT MQTT client. Please notice that it's not possible to download the private key from AWS once it has been generated, by the way we securely store it inside our database. We may consider to allow its download in the future, so that you could also directly send your device to AWS, by passing Pybytes.\nWarning: do not delete AWS things or groups directly from AWS user interface, otherwise the integration with Pybytes will stop working. Always use Pybytes interface to delete AWS things or groups.\n"},"docnotes/introduction.html":{"url":"docnotes/introduction.html","title":"Introduction","keywords":"","body":"Introduction\nThe Pycom documentation aims to be straightforward and to adhere to typical Python documentation to allow for ease of understanding. However, there may be some unusual features for those not used to Python documentation or that are new to the MicroPython Language. This section of the documentation aims to provide clarity for any of the design specifics that might be confusing for those new to Python and this style of documentation.\n"},"docnotes/syntax.html":{"url":"docnotes/syntax.html","title":"Syntax","keywords":"","body":"Syntax\nThe Pycom documentation follows standard Python Library format using the popular Sphinx Docs tool. There are some notable points regarding the syntax of classes, methods and constants. Please see the notes below and familiarise yourself with the specific details before reviewing the documentation.\nKeyword Arguments\nKeyword Arguments refer to the arguments that are passed into a constructor (upon referencing a class object). When passing values into a MicroPython constructor it is not always required to specify the name of the argument and instead rely on the order of the arguments passed as to describe what they refer to. In the example below, it can be seen that the argument mode is passed into the i2c.init() method without specifying a name.\nThe values of the arguments (as seen in the examples/docs) refer to the default values that are passed into the constructor if nothing is provided.\ni2c.init(mode, * , baudrate=100000, pins=(SDA, SCL))\n\nAn example of how this method might be called:\ni2c.init(I2C.MASTER, pins=('P12', 'P11'))\n\nIt can be seen that a value for baudrate was not passed into the method and thus MicroPython will assume a default value of 100000. Also the first argument mode was not specified by name, as the constructor does not require it, denoted by the lack of an = symbol in the constructor documentation.\nPassing Arguments into a Method\nIt is important to note that there are certain class methods that can only accept a keyword for certain arguments as well as some that only accept a value. This is intentional by design but is not always apparent to the user calling specific methods. The differences between the two are outlined below, with examples referencing where differences might apply and what to be aware of.\nKeyword\nAn astrik * in a method description (in the docs), denotes that the following arguments require a keyword, i.e. pin='P16' in the example below.\nadc.channel(* , pin, attn=ADC.ATTN_0DB)\n\nfrom machine import ADC\n\nadc = ADC() # create an ADC object\napin = adc.channel(pin='P16') # create an analog pin on P16\n\npin is a required argument and the method channel will not execute unless it is passed as with a keyword.\nAnother example shows how the PWM class, pwm.channel() requires a keyword argument for pin but does not for id.\nfrom machine import PWM\n\npwm = PWM(0, frequency=5000)\npwm_c = pwm.channel(0, pin='P12') # no keyword argument requires for id (0) but is required for pin (pin='P12')\n\nValue\nThe documentation may refer to a method that takes an argument listed by name but does allow for a keyword to be passed. For example, the pycom class contains a method rgbled. This lists that the method accepts a value for color, however this may not be specified by keyword, only value. This is intentional as the value being passed is the only argument valid for this method\npycom.rgbled(color)\n\nIf the argument is passed into the method with a keyword, it will return an error stating TypeError: function does not take keyword arguments.\nimport pycom\n\npycom.rgbled(color=0xFF0000) # Incorrect\npycom.rgbled(0xFF0000) # Correct\n\nAnother example of a method that only accepts value input. In this case, the RTC.init() method require a value (tuple) input for the datetime. It will not accept a keyword.\nrtc.init(datetime)\n\nfrom machine import RTC\n\nrtc = RTC()\nrtc.init(datetime=(2014, 5, 1, 4, 13, 0, 0, 0)) # Incorrect\nrtc.init((2014, 5, 1, 4, 13, 0, 0, 0)) # Correct\n\nConstants\nThe constants section of a library within the docs refers to specific values from that library's class. These might be used when constructing an object from that class or when utilising a method from within that class. These are generally listed by the library name followed by the specific value. See the example below:\nI2C.MASTER()\n\nBe aware that you can only reference these constants upon importing and constructing a object from a library.\n\n"},"docnotes/replscript.html":{"url":"docnotes/replscript.html","title":"REPL vs Scripts","keywords":"","body":"REPL vs Scripts\nUsers of this documentation should be aware that examples given in the docs are under the expectation that they are being executed using the MicroPython REPL. This means that when certain functions are called, their output may not necessarily be printed to the console if they are run from a script. When using the REPL many classes/functions automatically produce a printed output displaying the return value of the function to the console. The code snippet below demonstrates some examples of classes/functions that might display this behaviour.\nBasic Arithmetic\n1 + 1 # REPL will print out '2' to console\n1 + 1 # Script will not return anything the console\nprint(1 + 1) # Both the REPL and a script will return '2' to the console\n\nCalling Methods\nimport ubinascii\n\nubinascii.hexlify(b'12345') # REPL will print out \"b'3132333435'\" to the console\nubinascii.hexlify(b'12345') # Script will not return any the console\n\nIn order to use these functions that do not print out any values, you will need to either wrap them in a print() statement or assign them to variables and call them later when you wish to use them.\nFor example:\n# immediately print to console when using a script\nprint(1 + 1)\n# or save variable to for later\nvalue = 1 + 1\n# do something here...\nprint(value)\n\n"},"docnotes/mesh-networks.html":{"url":"docnotes/mesh-networks.html","title":"Mesh Networks","keywords":"","body":"Mesh Networks\nMesh Networking is currently under development. Please click here for the documentation. Please keep in mind that this document is still only informational.\n"},"advance/downgrade.html":{"url":"advance/downgrade.html","title":"Firmware Downgrade","keywords":"","body":"Firmware Downgrade\nThe firmware upgrade tool usually updates your device to the latest available firmware version. If you require to downgrade your device to a previous firmware there are two methods to achieve this.\nIf you are using an Expansion Board 1.0 or 2.0, you will need to have a jumper connected between G23 and GND to use either procedure below. You will also need to press the reset button before beginning.\n\nYou can obtain previous firmware versions here:\n\nWiPy\nLoPy\nSiPy\nGPy\nFiPy\nLoPy4\n\nPrior to version 1.16.0.b1 the firmware for modules with LoRa functionality was frequency specific. From 1.16.0.b1 and onward, the firmware is region agnostic and this can either be set programatically or via the config block (see here).\n\nGUI\nAs of version 1.12.0.b0 of the firmware update tool, you can now provide a .tar or .tar.gz archive of the firmware you wish to upload to the board.\nWhen you start the update tool you will see the following screen:\n\nWhen you tick the Flash from local file option, an address bar will appear. Click the ... button and locate the .tar(.gz) file with the firmware you wish to flash to your device. From this point the updater will behave just like a regular update but using the local file instead of downloading the latest.\nCommand line\nYou can also use the CLI version of the update tool to downgrade your device. Will need to get a .tar or .tar.gz archive of the firmware you wish to upload to the board. Then run the following commands:\n$ pycom-fwtool-cli -v -p PORT flash -t /path/to/firmware/archive.tar.gz\n\n"},"advance/cli.html":{"url":"advance/cli.html","title":"CLI Updater","keywords":"","body":"CLI Updater\nCommand Line Update Utility\nWindows\nAfter installing the Windows version of the updater tool, the CLI tool pycom-fwtool-cli.exe can be found here:\n\n32-Bit Windows: C:\\Program Files\\Pycom\\Pycom Firmware Update\\\n64-Bit Windows: C:\\Program Files (x86)\\Pycom\\Pycom Firmware Update\\\n\nmacOS\nIn order to get access to the CLI tool on macOS, you will need to right click on the Mac version of the updater tool and click Show Package Contents, then navigate to Contents/Resources, here you will find the pycom-fwtool-cli.\nLinux\nIn the Ubuntu 14.04 LTS (and newer) version of the updater tool, pycom-fwtool-cli is installed in /usr/local/bin. In the Generic Linux package, the tool is extracted into folder ./pyupgrade\nUsage\nusage: pycom-fwtool-cli [-h] [-v] [-d] [-q] [-p PORT] [-s SPEED] [-c] [-x]\n [--ftdi] [--pic] [-r]\n {list,chip_id,wmac,smac,sigfox,exit,flash,copy,write,write_remote,wifi,pybytes,cb,nvs,ota,lpwan,erase_fs,erase_all}\n ...\n\nUpdate your Pycom device with the specified firmware image file For more\ndetails please see https://docs.pycom.io/chapter/advance/cli.html\n\npositional arguments:\n {list,chip_id,wmac,smac,sigfox,exit,flash,copy,write,write_remote,wifi,pybytes,cb,nvs,ota,lpwan,erase_fs,erase_all}\n list Get list of available COM ports\n chip_id Show ESP32 chip_id\n wmac Show WiFi MAC\n smac Show LPWAN MAC\n sigfox Show sigfox details\n exit Exit firmware update mode\n flash Write firmware image to flash\n copy Read/Write flash memory partition\n write Write to flash memory\n wifi Get/Set default WIFI parameters\n pybytes Read/Write pybytes configuration\n cb Read/Write config block\n nvs Read/Write non volatile storage\n ota Read/Write ota block\n lpwan Get/Set LPWAN parameters [ EU868 US915 AS923 AU915]\n erase_fs Erase flash file system area\n erase_all Erase entire flash!\n\noptional arguments:\n -h, --help show this help message and exit\n -v, --verbose show verbose output from esptool\n -d, --debug show debuggin output from fwtool\n -q, --quiet suppress success messages\n -p PORT, --port PORT the serial port to use\n -s SPEED, --speed SPEED\n baudrate\n -c, --continuation continue previous connection\n -x, --noexit do not exit firmware update mode\n --ftdi force running in ftdi mode\n --pic force running in pic mode\n -r, --reset use Espressif reset mode\n\nHow to use the Parameters\nThe CLI tool uses a combination of global and command specific parameters. The order of parameters is important to avoid ambiguity.\npycom-fwtool-cli [global parameters] [command] [command parameters]\nWhile pycom-fwtool-cli -h shows help for global parameters and a list of available commands, command specific parameters can be viewed using pycom-fwtool-cli [command] -h\nThe parameter -r, --reset has been added as a courtesy for users of 3rd party ESP32 products. This functionality is not supported by the Expansion Board 2.0 and may cause this tool to crash or hang in certain circumstances.\n\nGlobal Parameters\n`-h / --help` : shows above help (you can also get detailed help for each sub-command\n`-v / --verbose` : show verbose output from esptool.\n`-d / --debug` : show debug output from fwtool.\n`-q / --quiet` : suppress most output, used for scripting\n`-p / --port` : specifies the serial port to be used. Can also be set via **environment variable ESPPORT**\n`-s / --speed` : specifies the serial speed to be used. Can also be set via **environment variable ESPBAUD**\n`-c / --continuation` : continue previous connection in FTDI mode. This allows running multiple commands sequentially without having to reset the module. This option is ignored in PIC mode as the module can be reset via the serial connection.\n`-x / --noexit` : This will prevent the PIC from leaving firmware update mode.\n`--ftdi` : This will force the CLI updater to run in FTDI mode.\n`--pic` : This will force the CLI updater to run in PIC mode.\n`-r, --reset` : This will force the CLI updater to use Espressif's workaround to switch into Firmware update mode. This reset method is intended for 3rd party hardware only and is not supported by the Expansion Board 2.0\n\nCommands\nlist\nGet list of available serial ports ports.\nusage: pycom-fwtool-cli list [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nExample: On macOS:\n$ pycom-fwtool-cli list\n/dev/cu.usbmodemPy343431 [Pytrack] [USB VID:PID=04D8:F013 SER=Py343434 LOCATION=20-2]\n/dev/cu.Bluetooth-Incoming-Port [n/a] [n/a]\n\nOn Windows:\nCOM6 [Pytrack] [USB VID:PID=04D8:F013 SER=Py343434 LOCATION=20-2]\n\nThis is the only command that does not require any additional parameters.\nAll other commands require that the serial port is specified either through the -p / --port option or through environment variable ESPPORT You can optionally specify the speed either through -s / --speed or via environment variable ESPBAUD. The default speed is 921600. The maximum speed for read operations on PIC based expansion boards & shields is 230400. The speed will be reduced automatically if necessary.\nSpecial note for Expansion Board 2.0\nYou will need to have a jumper wire connected between G23 and GND to use any of the commands below. You will also need to press the reset button either before running each command or at least before running the first command. To avoid having to press the reset button again after each command, you can use the -c / --continuation option. The first command connecting to the device MUST NOT use the -c / --continuation option. This is to make sure a program called _stub_ is uploaded onto the device. This _stub_ cannot be uploaded more than once, so you need to tell the cli tool that the _stub_ is already running, which is done through using the -c / --continuation option.\n\nchip_id\nShows the unique ID of the ESP32 on the connected module.\nusage: pycom-fwtool-cli -p PORT exit [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nwmac\nShows the WiFi MAC of the connected module.\nusage: pycom-fwtool-cli -p PORT wmac [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nsmac\nShows the LPWAN MAC of the connected module.\nusage: pycom-fwtool-cli -p PORT smac [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nsigfox\nShow sigfox details\nusage: pycom-fwtool-cli -p PORT sigfox [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nexit\nIf a Pysense/Pytrack/Expansion 3 has previously been left in firmware update mode by using the -x option, this command can be used to exit the firmware update mode.\nusage: pycom-fwtool-cli -p PORT exit [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nflash\nWrites firmware image to flash, must be as a .tar(.gz) file as provided by Pycom. These files can be found on GitHub.\nusage: pycom-fwtool-cli -p PORT flash [-h] [-t TAR]\n\noptional arguments:\n -h, --help show this help message and exit\n -t TAR, --tar TAR perform the upgrade from a tar[.gz] file\n\ncopy\nRead/Write flash memory partition from/to local file\nusage: pycom-fwtool-cli -p PORT [-h] [-p PARTITION] [-f FILE] [-r] [-b]\n\noptional arguments:\n -h, --help show this help message and exit\n -p PARTITION, --partition PARTITION\n The partition to read/write (all, fs, nvs, factory,\n secureboot, bootloader, partitions, otadata, fs1,\n ota_0, config)\n -f FILE, --file FILE name of the binary file (default: -.bin)\n -r, --restore restore partition from binary file\n -b, --backup backup partition to binary file (default)\n\nwrite\nWrite to a specific location in flash memory.\nusage: pycom-fwtool-cli -p PORT write [-h] [-a ADDRESS] [--contents CONTENTS]\n\noptional arguments:\n -h, --help show this help message and exit\n -a ADDRESS, --address ADDRESS\n address to write to\n --contents CONTENTS contents of the memory to write (base64)\n\nwifi\nGet/Set default WiFi parameters.\nusage: pycom-fwtool-cli wifi [-h] [--ssid SSID] [--pwd PWD] [--wob [WOB]]\n\noptional arguments:\n -h, --help show this help message and exit\n --ssid SSID Set Wifi SSID\n --pwd PWD Set Wifi PWD\n --wob [WOB] Set Wifi on boot\n\npybytes\nRead/Write pybytes configuration.\nusage: pycom-fwtool-cli pybytes [-h] [--token TOKEN] [--mqtt MQTT] [--uid UID]\n [--nwprefs NWPREFS] [--extraprefs EXTRAPREFS]\n\noptional arguments:\n -h, --help show this help message and exit\n --token TOKEN Set Device Token\n --mqtt MQTT Set mqttServiceAddress\n --uid UID Set userId\n --nwprefs NWPREFS Set network preferences\n --extraprefs EXTRAPREFS\n Set extra preferences\n\nNote: The local pybytes_config.json file is overwritten when making any modifications using this command (requires Pybytes firmware 1.17.5.b6 or higher and Firmware updater 1.14.3).\n\ncb\nRead/Write config block (LPMAC, Sigfox PAC & ID, etc.). You can find the structure of this block here.\nusage: pycom-fwtool-cli -p PORT cb [-h] [-f FILE] [-b] [-r]\n\noptional arguments:\n -h, --help show this help message and exit\n -f FILE, --file FILE name of the backup file\n -b, --backup backup cb partition to file\n -r, --restore restore cb partition from file\n\nIf neither -b or -r is provided, the command will default to backup. If no file name is provided, .cb is used.\nTo backup your config block: $pycom-fwtool-cli -p PORT cb\nTo restore your config block: $pycom-fwtool-cli -p PORT cb -r -f backup.cb\nnvs\nRead/Write non-volatile storage.\nusage: pycom-fwtool-cli -p PORT nvs [-h] [-f FILE] [-b] [-r]\n\noptional arguments:\n -h, --help show this help message and exit\n -f FILE, --file FILE name of the backup file\n -b, --backup backup cb partition to file\n -r, --restore restore cb partition from file\n\nIf neither -b or -r is provided, the command will default to backup. If no file name is provided, .nvs is used.\nTo backup your NVS: $ pycom-fwtool-cli -p PORT nvs\nTo restore your NVS: $ pycom-fwtool-cli -p PORT nvs -r -f backup.nvs\nota\nRead/Write ota block, this contains data relating to OTA updates such as the hash of the OTA firmware.\nusage: pycom-fwtool-cli ota [-h] [-f FILE] [-b] [-r]\n\noptional arguments:\n -h, --help show this help message and exit\n -f FILE, --file FILE name of the backup file\n -b, --backup backup cb partition to file\n -r, --restore restore cb partition from file\n\nIf neither -b nor -r is provided, the command will default to backup. If no file name is provided, .ota is used.\nTo backup your OTA block: $pycom-fwtool-cli -p PORT ota\nTo restore your OTA block: $pycom-fwtool-cli -p PORT ota -r -f backup.ota\nlpwan\nGet/Set LPWAN parameters saved to non-volatile storage. Please see here for more details.\nusage: pycom-fwtool-cli -p PORT lpwan [-h] [--region REGION]\n\noptional arguments:\n -h, --help show this help message and exit\n --region REGION Set default LORA region\n --erase_region Erase default LORA region\n --lora_region Output only LORA region\n\nerase_fs\nErase flash file system area. This is useful if some code running on the device is preventing access to the REPL.\nusage: pycom-fwtool-cli -p PORT erase_fs [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nerase_all\nErase entire flash, only use this if you are sure you know what you are doing. This will remove your devices lpwan mac addresses etc.\nusage: pycom-fwtool-cli erase_all [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\n"},"advance/encryption.html":{"url":"advance/encryption.html","title":"SecureBoot and Encryption","keywords":"","body":"SecureBoot and Encryption\nSummary\nIn order to encrypt your firmware, you will need to build it from source. Our firmware source code can be found here, along with instructions on how to build it. Below you will find specific instructions on how generate keys, build and flash encrypted firmware.\n\nObtain keys (for Secure Boot and Flash Encryption)\nFlash keys and parameters in efuses\nCompile bootloader and application with make SECURE=on\nFlash: bootloader-digest at address 0x0 and encrypted; all the others (partitions and application) encrypted, too.\n\nPrerequisites\nFirstly you will need to setup the tool chain and download the source code. detailed instructions on how to achieve this can be found here. Once you have complete this, you will need to open a terminal in the esp32 folder of the firmware source code repo.\nNext you will need keys for Flash Encryption and Secure Boot; they can be generated randomly with the following commands:\npython $IDF_PATH/components/esptool_py/esptool/espsecure.py generate_flash_encryption_key flash_encryption_key.bin\npython $IDF_PATH/components/esptool_py/esptool/espsecure.py generate_signing_key secure_boot_signing_key.pem\n\nThe Secure Boot key secure_boot_signing_key.pem has to be transformed into secure-bootloader-key.bin, to be burnt into efuses. This can be done in 2 ways:\npython $IDF_PATH/components/esptool_py/esptool/espsecure.py extract_public_key --keyfile secure_boot_signing_key.pem signature_verification_key.bin\n\nor, as an artifact of the make build process, on the same directory level as Makefile\nmake BOARD=GPY SECURE=on TARGET=boot\n\nTo flash the keys (flash_encryption_key.bin and secure-bootloader-key.bin) into the efuses (write and read protected) run the following commands (ignoring the lines that start with #):\nNote: Irreversible operations\n# Burning Encryption Key\npython $IDF_PATH/components/esptool_py/esptool/espefuse.py --port /dev/ttyUSB0 burn_key flash_encryption flash_encryption_key.bin\n# Burning Secure Boot Key\npython $IDF_PATH/components/esptool_py/esptool/espefuse.py --port /dev/ttyUSB0 burn_key secure_boot secure-bootloader-key.bin\n# Enabling Flash Encryption mechanism\npython $IDF_PATH/components/esptool_py/esptool/espefuse.py --port /dev/ttyUSB0 burn_efuse FLASH_CRYPT_CNT\n# Configuring Flash Encryption to use all address bits together with Encryption key (max value 0x0F)\npython $IDF_PATH/components/esptool_py/esptool/espefuse.py --port /dev/ttyUSB0 burn_efuse FLASH_CRYPT_CONFIG 0x0F\n# Enabling Secure Boot mechanism\npython $IDF_PATH/components/esptool_py/esptool/espefuse.py --port /dev/ttyUSB0 burn_efuse ABS_DONE_0\n\nIf the keys are not written in efuse, before flashing the bootloader, then random keys will be generated by the ESP32, they can never be read nor re-written, so bootloader can never be updated. Even more, the application can be re-flashed (by USB) just 3 more times.\nMakefile options\nmake BOARD=GPY SECURE=on SECURE_KEY=secure_boot_signing_key.pem ENCRYPT_KEY=flash_encryption_key.bin TARGET=[boot|app]\n\n\nSECURE=on is the main flag; it's not optional\nif SECURE=on the following defaults are set:\nencryption is enable \nsecure_boot_signing_key.pem is the secure boot key, located relatively to Makefile\nflash_encryption_key.bin is the flash encryption key, located relatively to Makefile\n\n\n\nFor flashing the bootloader digest and the encrypted versions of all binaries:\nmake BOARD=GPY SECURE=on flash\n\nFlashing\nFor flashing the bootloader-reflash-digest.bin has to be written at address 0x0, instead of the bootloader.bin (at address 0x1000).\nBuild is done using SECURE=on option; additionally, all the binaries are pre-encrypted.\nmake BOARD=GPY clean\nmake BOARD=GPY SECURE=on TARGET=boot\nmake BOARD=GPY SECURE=on TARGET=app\nmake BOARD=GPY SECURE=on flash\n\nManual flash command:\npython $IDF_PATH/components/esptool_py/esptool/esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 921600 --before no_reset --after no_reset write_flash -z --flash_mode dio --flash_freq 80m --flash_size detect 0x0 build/GPY/release/bootloader/bootloader-reflash-digest.bin_enc 0x8000 build/GPY/release/lib/partitions.bin_enc 0x10000 build/GPY/release/gpy.bin_enc_0x10000\n\nOTA update\nThe OTA should be done using the pre-encrypted application image.\nBecause the encryption is done based on the physical flash address, there are 2 application binaries generated:\n\ngpy.bin_enc_0x10000 which has to be written at default factory address: 0x10000\ngpy.bin_enc_0x1A0000 which has to be written at the ota_0 partition address (0x1A0000)\n\nHint: on MicroPython interface, the method pycom.ota_slot() responds with the address of the next OTA partition available (either 0x10000 or 0x1A0000).\n\n"},"documents/certificates.html":{"url":"documents/certificates.html","title":"Certificates","keywords":"","body":"Certificates\nCE RED\nDevelopment Boards\nLoPy\nLoPy CE RED Certificate\nWiPy 2.0\nWiPy 2.0 CE RED Certificate\"\nWiPy 3.0\nWiPy 3.0 CE RED Certificate\nSiPy\nSiPy CE RED Certificate\nGPy\nGPy CE RED Certificate.pdf)\nFiPy\nFiPy CE RED Certificate\nOEM Modules\nL01\nL01 CE RED Certificate\nW01\nW01 CE RED Certificate\nG01\nG01 CE RED Certificate\nFCC\nDevelopment Boards\nLoPy\nLoPy FCC Certificate\nLoPy FCC Certificate\nLoPy FCC Certificate\nWiPy 2.0\nWiPy 2.0 FCC Certificate\nWiPy 2.0 FCC Certificate\nGPy\nGPy FCC Certificate\nGPy FCC Certificate\nGPy FCC Certificate\nFiPy\nFiPy FCC Certificate\nFiPy FCC Certificate\nFiPy FCC Certificate\nFiPy FCC Certificate\nOEM Modules\nL01\nL01 FCC Certificate\nL01 FCC Certificate\nL01 FCC Certificate\nW01\nW01 FCC Certificate\nW01 FCC Certificate\nG01\nG01 FCC Certificate\nG01 FCC Certificate\nG01 FCC Certificate\n"},"documents/license.html":{"url":"documents/license.html","title":"License","keywords":"","body":"License\nThe MIT License (MIT)\nCopyright (c) 2013-2015 Damien P. George, and others\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\nTHE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\nCopyright (c) 2017, Pycom Limited.\nThis software is licensed under the GNU GPL version 3 or any later version, with permitted additional terms. For more information see the Pycom Licence v1.0 document supplied with this file, or available at https://www.pycom.io/opensource/licensing\n"}}} \ No newline at end of file +{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["&","api","avail","begin","build","develop","document","exampl","familiaris","featur","feel","free","get","guid","help","info","introduct","jump","module.","product","projects.","pybyt","pycom","pymakr","read","recommend","section","site.","start","started,","straight","through","tool","tutori","variou","welcom","yourself"],"products.html":["##","&","(universal)","(user","3.0","accessori","antenna","batteri","below","bluetooth","board","cabl","case","cat","certain","compat","develop","each","expans","extern","find","fipi","function","functionality.","g01","gpi","illustr","iot","ip67","kit","l01","l01/w01","l04","lipo","lopi","lopy4","lora","lte","m","m1nb","micro","modul","oem","other,","product","products,","products.","pycas","pycom","pyscan","pysens","pysense/pytrack/pyscan","pytrack","refer","requir","sigfox","sipi","supplied)","tabl","univers","usb","utilis","variou","w01","well","wifi","wifi/bt","wipi","✔"],"gettingstarted/introduction.html":["1:","2:","3:","4:","accessori","advertis","antenna","arrow","basic","befor","begin","bottom","button","card","check","chosen","comput","congratul","connect","connected,","cover","decid","decision.","detail","develop","devic","device.","direct","doubt","drivers;","ensur","exampl","excel","explain","familiar","featur","firmwar","first","firstli","get","guid","guide,","hardwar","haven't","highli","instal","interfac","introduct","it.","keen","know","make","modul","module.","module/accessori","navig","need","network","network.","networks.","now","on","order","out","pack","page","page.","part","perform","place","point","product","program","pycom","recommend","regist","registration.","requir","require.","right","second","secondli","set","setup","sim","so,","softwar","stabl","start","step","successfulli","such","take","through","time","up","updat","us","usb","usual","variou","version;","via","wifi.","wireless","you'v"],"gettingstarted/connection/":["adapt","antenna","appropri","base","below","boards,","chapter","connect","connect.","detail","devic","document","each","guide.","hardwar","instruct","modul","module.","need","on","pleas","pycom","select","setup","show","taken","uart","usb","well","wifi"],"gettingstarted/connection/lopy.html":["(locat","(optional)","2.0","2.0exp","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","433mhz.","5.5v","868mhz","915mhz","access","adapterwifilook","align","antenna","antenna.","are:","bands.","basic","befor","better","between","blocked.","board","board,","board.","boots,","both","button","caus","chip","click","come","connect","connection.in","connector","connector.","consumpt","convert","corner","correctly,","creat","credentials:","current","damag","dc","deep","default,","detail","devic","device,","device.","done","down","down.","edg","ensur","even","exp","expans","experi","explan","extern","final","firmli","firmwar","first","firstli","flash","flat","follow","found","ftp","here.","high","hole,","includ","insert","instruct","intend","issu","led).","led.","locat","lock","login","longer","look","lopi","lopy,","lopy.","lopy4.","lopy:","lora","maintain","memori","method","micro","mode","mode.","modul","modules,","more","mount","need","network","newer","next","note:","now","nut.","onc","option","order","otherwis","out","password:","perform","pig","pin","pin.","place","point","possibl","power","products.","provid","put","pycase,","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","recommend","remain","requir","reset","resolv","risk","run","same","screw","server","side","signal","sipy,","sleep","sleep.","sma","software,","ssid:","such","suppli","support","switch","tail","telnet","through","time","toward","tri","u.fl","uart","updat","us","usb","username:","users.","via","vin","visible.","way","well","wifi","wifi/bluetooth","wipi","wlan","www.pycom.io","yourself"],"gettingstarted/connection/lopy4.html":["&","(locat","(lora","(optional)","2.0exp","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","4","433mhz","5.5v","868mhz/915mhz","access","adapterwifilook","align","antenna","antenna.","appropri","are:","band","basic","befor","better","between","blocked.","board","board,","board.","boots,","both","button","chip","click","come","connecor.","connect","connection.in","connector","connector.","corner","correctly,","creat","credentials:","damag","default,","detail","device,","device.","differ","done","down","edg","ensur","exp","expans","extern","final","firmli","firmwar","first","firstli","flat","follow","found","frequenc","ftp","hand","here.","hole,","includ","insert","instruct","intend","led).","led.","left","locat","lock","login","longer","look","lopi","lopy.","lopy4","lopy4,","lopy4.","lopy4:","lora","lora/sigfox","method","micro","modul","modules,","mount","need","network","next","note:","now","nut.","on","onc","only),","option","order","otherwis","out","password:","perform","pig","pin","pin.","place","point","possibl","power","provid","put","pycase,","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","recommend","requir","reset","right","risk","run","same","screw","server","side","sigfox).","signal","sma","software,","ssid:","such","suit","suppli","switch","tail","telnet","through","time","toward","tri","two","u.fl","uart","updat","us","usb","username:","users.","using.","via","vin","visible.","way","well","wifi","wifi/bluetooth","wlan","www.pycom.io","yourself"],"gettingstarted/connection/sipy.html":["(locat","(optional)","2.0","2.0exp","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","5.5v","access","adapterwifilook","align","antenna","antenna.","are:","basic","befor","better","between","blocked.","board","board,","board.","boots,","both","button","caus","chip","click","come","connect","connection.in","connector","connector.","consumpt","convert","corner","correctly,","creat","credentials:","current","damag","dc","deep","default,","detail","devic","device,","device.","done","down","down.","edg","ensur","even","exp","expans","experi","explan","extern","final","fipi","fipy,","firmli","firmwar","first","firstli","flash","flat","follow","found","ftp","here.","high","hole,","includ","insert","instruct","intend","issu","led).","led.","locat","lock","login","longer","look","lopy,","maintain","memori","method","micro","mode","mode.","modul","modules,","more","mount","need","network","newer","next","note:","now","nut.","onc","option","order","otherwis","out","password:","perform","pig","pin","pin.","place","point","possibl","power","products.","provid","put","pycase,","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","recommend","remain","requir","reset","resolv","risk","run","same","screw","server","side","sigfox","signal","sipi","sipy,","sipy.","sipy:","sleep","sleep.","sma","software,","ssid:","such","suppli","switch","tail","telnet","through","time","toward","tri","u.fl","uart","updat","us","usb","username:","users.","via","vin","visible.","way","well","wifi","wifi/bluetooth","wipi","wlan","www.pycom.io","yourself"],"gettingstarted/connection/gpy.html":["(locat","(optional)","2.0exp","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","5.5v","access","acquir","adapterwifilook","antenna","antenna.","are:","basic","befor","best","better","between","blocked.","board","board,","board.","boots,","both","button","card","cat","cellular","click","come","connect","connection.in","connector","connector.","contact","corner","creat","credentials:","damag","default,","detail","device,","device.","done","enabl","exp","expans","extern","firmli","firmwar","first","firstli","follow","found","ftp","gpi","gpy,","gpy.","gpy:","here.","includ","inform","insert","instruct","intend","iot","led).","led.","local","locat","lock","login","longer","look","lte","m1","m1/nb","method","micro","modul","modules,","more","mount","nano","nb","need","network","next","note","note:","now","onc","option","order","otherwis","out","password:","perform","pin","pin.","place","point","possibl","power","provid","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","recommend","regular","requir","reset","risk","run","same","server","side","signal","sim","sim.","software,","special","ssid:gpi","such","suppli","support","switch","telnet","time","toward","tri","u.fl","uart","updat","us","usb","username:","users.","via","vin","visible.","way","well","wifi","wifi/bluetooth","wlan","www.pycom.io","yourself"],"gettingstarted/connection/fipy.html":["(locat","(optional)","2.0exp","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","433mhz.","5.5v","868mhz","915mhz","access","acquir","adapterwifiwhen","align","antenna","antenna.","are:","bands.","basic","befor","best","better","between","blocked.","board","board,","board.","boots,","both","button","card","cat","cellular","click","come","commun","connect","connection.in","connector","connector.","contact","corner","correctly,","creat","credentials:","ct","damag","default,","detail","device,","device.","done","down","edg","enabl","ensur","exp","expans","extern","final","fipi","fipy,","fipy.","fipy:","firmli","firmwar","first","firstli","flat","follow","found","ftp","here.","hole,","includ","inform","insert","instruct","intend","interfer","iot","jumper","led).","led.","local","locat","lock","login","longer","look","lopy4.","lora","lora/sigfox","lte","m1","m1/nb","method","micro","modem.","modul","modules,","more","mount","nano","nb","need","network","next","note","note:","now","nut.","onc","option","order","otherwis","out","password:","perform","pig","pin","pin.","place","point","possibl","power","provid","put","pycase,","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","recommend","regular","remov","requir","reset","risk","rt","run","same","screw","server","side","signal","sim","sim.","sma","software,","special","ssid:","such","suppli","support","switch","tail","telnet","through","time","toward","tri","u.fl","uart","under","updat","us","usb","username:","users.","via","vin","visible.","way","well","wifi","wifi/bluetooth","wlan","www.pycom.io","yourself"],"gettingstarted/connection/wipy.html":["(locat","(optional)","(p12)","2.0","2.0exp","3.0","3.0,","3.0.","3.0pytrack/pysense/pyscanusb","3.5v","4mb","4mb.","5.5v","512kb","8mb.","access","adapterwifilook","antenna","antenna.","are:","basic","befor","better","between","blocked.","board","board,","board.","boots,","both","button","caus","changes:","chip","click","come","connect","connection.in","connector","connector.","consumpt","convert","corner","creat","credentials:","current","dc","deep","deepsleep","default,","detail","devic","device,","done","down.","even","exp","expans","experi","explan","extern","firmli","firmwar","first","firstli","fix","flash","follow","found","ftp","gpio21","here.","high","includ","insert","instruct","issu","led).","locat","lock","login","longer","look","lopy,","maintain","memori","method","micro","mode","mode.","modul","modules,","more","mount","move","need","network","newer","next","note:","now","onc","option","order","out","password:","perform","pin","pin.","place","point","possibl","power","products.","provid","pycom","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","python","ram","recommend","remain","requir","reset","resolv","run","select","server","signal","sipy,","sleep","sleep.","software,","ssid:","such","suppli","switch","telnet","time","toward","u.fl","uart","updat","upgrad","usb","username:","users.","version","via","vin","visible.","vs","way","well","wifi","wifi/bluetooth","wipi","wipy,","wipy.","wipy:","wlan","www.pycom.io","yourself"],"gettingstarted/installation/":["activ","allow","assist","atom","attempt","autom","befor","code","connectivity.","correctly.","develop","devic","device.","devices:","driver","drivers:","e.g.","easy.","editor","enable.","ensur","environment:","favourit","featur","firmwar","firmware,","free","function","import","instal","make","microsoft","modul","pack","plug","process","product","program","provid","pycom","pymakr","requir","running,","sigfox","simplifi","softwar","stabl","studio","suit","super","text","tool","two","up","updat","upgrad","upload","us","utility:","visual","windows,","year"],"gettingstarted/installation/drivers.html":["(e.g.","(save",".zip","3.0","7,","8/10/+.","`devic","access","ad","adjust","anyth","anyway","back","befor","below.","board","box","brows","can't","check","click","comput","computer)","confirm","contained.","correct,","correctli","devic","devices.","dialout","distribut","done","download","driver","driver.","dropdown","extract","file","file,","first","folder","folder).","folder.","gone","group.","haven't","instal","installed.","instruct","label","link","linux","linux.","maco","make","manag","manager.","menu","navig","need","next","now","offici","open","option","out","permiss","pleas","point","port.","product","publish","pysense/pytrack/pyscan/expans","pytrack/pysens","receiv","recognis","right","search/navig","see","select","serial","shouldn't","softwar","software.","special","specif","specifi","start","successful,","suggest","support","sure","this.","under","updat","us","user","verifi","warn","warning,","window","work","work."],"gettingstarted/installation/firmwaretool.html":["(10.11","(button","(requir","2.0exp","3.0disconnect","ad","appropri","avail","basic","below,","between","board","board,","box","cabl","cable/wir","carefully:","come","comput","computer,","connect","constantli","devic","device.","devices.","dialog","done","download","dure","exp","expans","fail.","featur","firmwar","follow","found","g23","gnd","have","here","here.","higher)","improv","insert","instruct","issues,","jumper","jumpers,","latest","link","linux","loos","maco","make","mode'.","modul","new","now","on","on),","os","package)","pleas","plugin","power","present","previou","procedur","program","put","pymakr","python","readi","reboot","recommend","reconnect","remov","run","rx","screen.","serial","sometim","step","strongli","sure","tool","tool.","transport.","tx","updat","upgrad","upgrading,","upload","us","usb","version","via","window","wire","without","you'r","‘firmwar"],"gettingstarted/installation/pymakr.html":["avail","built","call","develop","easi","editors,","follow","make","platforms:","plugin","popular","possibl","pycom","pymakr","pymakr.","text","two"],"gettingstarted/programming/":["(read","access","allow","alreadi","avail","begin","below.","blink","board","boot","boot:","brows","code","comprehens","computer,","connect","detail","devic","device,","device.","directli","discuss","easiest","easili","enabled,","evalu","exampl","examples:","explain","explor","familiar","familiaris","file","first","follow","free","ftp","ftp:","goe","good","greater","guid","highli","how.","instal","interact","internet","interpreter.","introduct","is,","it.","know","learn","led.","loop)","mani","meant","mechan","micropython","micropython:","modul","module,","module.","network,","new","now","offend","onc","over","page","pages:","physic","platform.","point","possibl","prevent","print","program","programming.","project","project:","pycom","pymakr","pymakr,","python","python,","python.","read","recommend","recov","refer","relat","remov","repl","repl:","requir","rgb","run","safe","script","scripts.","search","server","server,","set","short","simpl","skill","softwar","someth","start","structur","syntax.","take","telnet.","termin","test","those","through","time","together,","tools,","transfer","tutori","tutorials.","type","uart","understand","up","updat","upload","us","variou","veri","via","way","well","wifi","wirelessly.","wish","wrong.","yourself"],"gettingstarted/programming/micropython.html":["&","/flash","3.5","3.5,","3.5.","access","allow","amount.","api","arduino,","automatically:","below.","block","board","board.","boot","boot.pi","booting,","brace","c.","c/c++","class","code","compat","control.","controllers.","definit","denot","design","develop","differences.","documentation.","enforced.","execut","faster","features.","file","firmwar","first","flow","folder","found","ftp","function","hardwar","here","implement","includ","indent","indentation,","indic","intent","introduct","level","librari","line","look","main.py.","major","manag","manner","mean","micro","micropython","micropython,","micropython;","minor","more","much","number","optimis","pictur","place","plugin.","process","provid","pymakr","python","refer","relat","run","same","section","share","similar","simpl","space","specif","specifi","statement","strictli","structur","syntax","taken","those","tip","trick","two","unlik","upward","us","variabl","variat","view","well,","within","work","written","{}"],"gettingstarted/programming/examples.html":["\"","\"!\"","\"hello","\"hello,","#","&","'2604","'bluetooth',","'fipy')","'gpy',","'lopy',","'lte","'sigfox',","'sipy',","'wifi'","'wifi',","'wipy'","('wipy',","(details).","(for","(i.e.","(micropython)","(names)","(regard","(sequence)","(the","+","+=","0","1","10","15","2)","3","3.5,","3.5.","9","9):","=",">","['lora',","add","add(1,","add(number1,","address","address_book","alex!\"","allow","anoth","assign","associ","awar","below","between","block","book","c","case,","cases.","check","code","code.","collect","condit","console.","contact","contain","control","crosswind","cycl","data","declar","def","depend","detail","dictionari","dictionaries,","differ","drive'","drive','chris':'3236","drive','joe':'1301","each","element","elif","equal","etc.","exampl","examples,","examples.","expect","explicitli","featur","find","function","functions/assignments/etc.","goldleaf","high!\")","hillview","his/her","hold","i.e.","immutable,","implement","import","input","instantiation.","items.","key","know","lane'}","language.","less","list","lists,","loop","loop)","loops,","m']","main","manag","mani","manipul","mean","memori","micropython","modifi","more","name","name,","name.","need","network","next","number","number1","number2","number2):","oper","option","order","out","output","over","parameters)","pass","passed.","passes.","person","phrase.","print","print(\"too","print(address_book['alex'])","print(networks[2])","print(pycom_devices[0])","print(variable)","print(welcome_phrase)","print(x)","program","provid","pycom_devic","python","range(0,","range.","refer","referenced.","repeat","result","result.","return","run","sensor","set","show","similar","size","specif","start","statement","store","string","strings,","structur","structures)","syntax,","take","target","target:","temperatur","there'","time","together,","true/false.","tupl","tutorials.","two","until","valu","value).","variabl","variables.","we'v","welcom","welcome(\"alex\")","welcome(name):","welcome_phras","within","world\"","x","y","you.","{'alex':'2604"],"gettingstarted/programming/first-project.html":["\"heartbeat\"","#","(if","(rgb","(so","(you",".pi","1",">",">>>","^","abov","access","add","allow","alt","amount","ap","api","atom","atom,","basis.","beat.","befor","beginn","below","between","blink","blink.","blue","blue.","board","boot.pi","boot.py.","bottom","built","button","button,","button.","c","call","case","case)","chang","check","click","clutter","cmd","code","code,","code.","code:","colour","colours.","come","command","complet","computer.","configur","confirm","connect","contain","control","copi","correctly.","coupl","creat","created,","ctrl","current","default","delays.","depend","detail","detect","devic","device'","device,","device.","directli","directori","directories.","disabl","documentation.","drawbacks.","e.g.","editor","empty,","even","exampl","example,","execut","explan","extra","featur","features,","file","file.","find","firmwar","firmware.","first","first).","first.","firstli","fix","flash","folder","follow","following:","forever.","format","found","ftp","function","global","good","green","guid","haven't","heart","here.","idea","identifi","import","in.","insid","instead","interact","intern","issue.","it'","it,","it.","keyboard.","know","l","larg","led","led.","lib","librari","libraries,","libraries.","load","long","longer","macos,","main","main.pi","make","manag","micropython","modul","module,","module.","more","move","name","need","network","new,","next","notic","now","on","on.","onc","onto","open","open,","options,","order","os","os.mkfs('/flash')","others,","out","over","pane","pane,","pane/bottom","permanently.","persist","point","popul","port","power","press","prevent","previou","previously.","program","project","project).","project,","project.","prompt).","put","pycom","pycom.heartbeat(false)","pycom.rgbled(0x0000ff)","pycom.rgbled(0x00ff00)","pycom.rgbled(0xff0000)","pymakr","pymakr.","pymakr.conf","quick","r","re","reboot","reboots,","red","regular","reload","remain","remov","repl","repl.","respons","return","rgb","run","script","script,","secondly,","section","see","serial","set","settings.","setup","setup,","shown","so:","some_library.pi","specif","split","standard","start","step","stop","structur","structure:","studio","sub","successfulli","such","sync_file_typ","take","telnet","terminal,","test","text","thing","this.","through","time","time.sleep(1)","tree.","true:","turn","two","type","up","upload","upload,","us","usabl","use.","variou","via","visual","want","way","wifi","window","windows,","windows/linux","wish","within","without","won't","work","yet,","|"],"gettingstarted/programming/repl/":["\"safe","access","addit","allow","arrow","auto","b","back.","below","blank","boot\"","boot.pi","both","c","cancel","charact","chunk","code","code.","code:","combinations;","commands.","complet","completion:","connections.","copi","copy/past","ctrl","current","d","d.","devic","devices.","down","e","easiest","echo","enter","evalu","except","execut","exit","explain","f","far","features:","follow","given","goe","halt","histori","history:","includ","input","input,","interact","interrupt","key","line","loop,","main.pi","main.py.","micropython","mode","mode,","mode.","mode'","modul","name","normal","number","out","output:","page","past","perform","perman","press","prevent","print","prompt","pycom","python","raw","read","repl","repl.","reset.","run","script","scroll","see","serial","shortcut","similar","soft","stand","tab","telnet","test","text.","through","up","us","usb","v","variabl","way","write","‘past"],"gettingstarted/programming/repl/serial.html":["$","'devic","'usb","(a","(com","(e.g.","(i.e.","(uart)","/dev/tty.usbmodem*","/dev/ttyusb01","115200","7","\\","\\.","access","add","additionally,","address","allow","alt","associ","atom","below","bind","board","bottom","box","button","click","code.","com","com4)","combin","command","command:","commands:","comput","connect","connected,","convert","copy/writ","creat","ctrl","detail","devic","device'","device.","diagram","directli","down","download","easiest","editor","elev","emul","enter","example,","exit","expans","explan","far","finally,","follow","found","free","get","group","hand","here.","higher","host","increment","inform","instanc","instead","instruct","key","keyboard","left","line","linux","linux,","list","located.","maco","macos,","manager'","menu","methods.","minicom","module).","multipl","name","need","next","obscur","open","open,","option","order","output","over","page","pane","panel","permiss","picocom","platform","plug","port","port)","press","program,","program.","putti","putty.","pycom","pymakr","q","q.","quit","radio","remap","repl","repl,","required),","required.","right","run","screen","screen,","screen.","search","serial","serial,","session","setup","shift","similar","start","studio","sudo)","support","termin","tool","ttyusb.","uart","upon","us","usb","used.","used;","uucp/dialout","via","visual","way","window","windows,","windows.","windows;","~/.screenrc"],"gettingstarted/programming/repl/telnet.html":["$","(23)","(ap)","(e.g.",").","192.168.4.1","192.168.4.1)","192.168.4.1,","above.","access","add","additionally,","address","allow","ap.","appear","are:","atom","authent","authentication.","board","bottom","chang","click","code.","connect","connection,","credenti","date,","default","detail","determin","devic","device'","device.","directli","download","earlier","easiest","editor","emul","enabl","enter","far","featur","final","first","follow","found","free","further","here.","home","host","info","instance,","instance.","instruct","ip","later","leav","linux","local","lopi","machin","maco","micro","mircopython","need","network.serv","network.wlan.","next","offic","onc","open","open,","option","output","over","pane","password","password:","personal,","platform","pleas","plug","point","point,","port","power","program","program,","prompt","putti","putty.","pycom","pymakr","python","re","refer","repl","required.","section","sections.","see","select","server","setup","ssid","still","studio","substitut","support","telnet","telnet,","termin","time","type","upon","us","used.","user","usernam","username:","via","visual","way","wifi","wifi/wlan.","window","windows;","www.pycom.io"],"gettingstarted/programming/ftp.html":["$","(insecure).","/flash","/flash.","192.168.4.1","access","activ","allow","alway","are:","avail","behav","boot","boot.pi","button.","call","card","chang","check","client","client,","clients,","command:","configur","configuration.","connect","correctly.","creat","default","defaults.","devic","device,","device.","document","doesn't","each","encrypt","ensur","example,","extern","file","filezilla","filezilla,","fireftp","flash","follow","ftp","ftp://192.168.4.1","ftp>","gener","immedi","import","in,","inform","information.","instead,","intern","it'","limit","locat","log","macos/linux","macos/linux:","manag","max","maximum","memory.","micro","microsd","mode,","mode.","more","mounted,","nativ","network.serv","new","number","on","one.","open","passiv","password:","plain","pleas","pycom","python","quick","recommend","run","see","serial","server","set","similar","site","small","specif","start","store","support","system","system.","tab,","terminal:","therefore,","time.","to:","transfer","unix","up,","url:","us","username:","via","visit","ways;","well.","windows:","within"],"gettingstarted/programming/safeboot.html":["(i.e.","(not","(updat","1st","2nd","3","3v3",">>>","access","achiev","again.","alreadi","alter","automat","aware,","be","be:","befor","begin","blink","block","boot","boot.pi","bootload","boots.","both","break","button,","card)","certain","clear","code","code,","code.","connect","count).","ctrl+d","cycl","data","delet","devic","device,","device.","disabl","drop","dure","during:","exampl","execut","explain","factori","faster.","file","filesystem","firmwar","firmware,","first,","fix","flash","follow","g23","gain","get","gnd","hard","hardwar","heartbeat","held","high","high,","imag","import","insid","interact","intern","it,","latest","leav","led","level","low","machin","machine.reset()","made","main.pi","main.py.","micropython","mode","mode.","mode;","modul","module.","need","never","next","normal","occur","orang","order","os","os.mkfs('/flash')","ota","output","p12","perform","peripher","persistent,","pin","pin),","possibl","power","press","prevent","previou","previous","problem","proce","procedur","program","put","pycom","pysense/pytrack","reach","receiv","recovered.","releas","remov","repl","repl.","repl:","requir","reset","reset,","resets.","run","run:","safe","same","script,","sd","sec","second","select","set","slowly.","socket","soft","standard","start","state","still","storag","straight","stuck","support","switch","sy","sys.exit()","therefor","time","tool","ty","unaffected.","up","updat","update,","upon","us","via","virtual","wifi/uart","window","wish","within","written","you."],"gettingstarted/registration/":["access","activ","activation;","avail","befor","below","box!","certain","devic","ensur","featur","features.","guid","immedi","list","networking.","out","platform","pleas","pycom","regist","registr","requir","see","setup","specif","such","type","utilis","variou","work"],"gettingstarted/registration/sigfox.html":["#","(not","(which","(you","=","account","account.","activated.","ad","address","alreadi","anymore.","assign","backend","backend,","backend.","befor","before.","binascii","chang","click","command","complet","confirm","copi","correct","countri","coupl","creat","credenti","devic","device'","device),","device).","device.","differ","don't","done,","dure","email","enter","find","firmwar","firmware.","first","go","green","https://backend.sigfox.com/activ","https://backend.sigfox.com/auth/login","id","import","includ","inform","initalis","know","last","latest","login","microchip","navig","need","network","new","now","number","onc","pac","pac.","page","password","print","print(binascii.hexlify(sigfox.id()))","print(binascii.hexlify(sigfox.pac()))","process.","provid","rcz","rcz1","rcz=sigfox.rcz1)","read","receiv","region)","regist","registration,","registration.","repl.","requir","same","screen","see","seen","select","sigfox","sigfox(mode=sigfox.sigfox,","specif","stabl","start,","success","sure","through","transfer","transfer.","updat","updater.","updates.","us","used,","valid","via","want","way"],"gettingstarted/registration/cellular.html":["(for","buy","card","carrier","cat","cellular","check","close","contact","current","deploy","detail","devic","differ","each","example,","find","gpy/fipi","here.","interest","iot.","it'","lab","local","lte","lte.","m1","map","nb","network","networks.","not).","note:","open","order","plan","provid","provider.","recommend","regist","requir","rule","show","sim","special","specif","standard","store,","such","support","surround","them,","trials,","us","whether"],"gettingstarted/registration/lora/":["(abp)","(otaa)","(which","70b3d5499585fca1.","8'))","=","above,","abp","achiev","activ","address,","air","along","applic","awar","below","capabl","code","code:","commun","connect","consid","contribut","desir","detail","devic","device.","directly.","document","each","enabl","encrypt","eui","eui,","exampl","favourit","find","firstli","follow","former","gener","github","guid","hex","ident","identifi","import","instruct","instructions,","key","key.","latter","like:","link","list","lora","lora(mode=lora.lorawan)","lora,","lorawan","method)","modul","need","network","network.","of.","onc","order","otaa","output","over","personalis","pleas","preconfigur","print(ubinascii.hexlify(lora.mac()).upper().decode('utf","prove","provid","pull","pycom","raw","recommend","regist","request.","secret","session","share","specif","string","talk","to,","tutori","ubinascii","unabl","uniqu","us","via","way.","wish","write"],"gettingstarted/registration/lora/ttn.html":["\"i'm","%","%s\"","&","'de","'fffe'","(a","(call","(default:","(e.g.","(must","(ttn)","(ubinascii.hexlify(lora.mac()).decode('ascii')))","+","48","48).","64","64).","868","=","abp","account","account.","act","activ","ad","added,","address","allow","antenna","appear,","applic","application.","applications.","applied,","belong","below","below,","between","binascii","binascii.hexlify(wl.mac())[6:]","binascii.hexlify(wl.mac())[:6]","bit","board","bring","button.","call","chang","click","code","complet","config.py)","configur","configuration:","configured.","connect","console,","correct","countri","creat","create/regist","data","defin","depend","descript","detail","devic","device.","each","email","enabl","enter","eu","eui","eui.","expand","expect","facto'","first","follow","form","forward","forwarder\"","found","frequenc","frequency.","gateway","gateway,","gateway.","gateways.","global","handler","here.","hexadecim","home","id","identifi","import","indoor","insid","know","legaci","locat","lora","lora()","lorawan","mac","match","method","mhz)","modul","nano","navig","need","network","network,","network.","new","next","node","now","number","number,","obtain","on","onc","open.","option","options,","order","otaa","otherwis","outdoor","overview","packet","page","page,","panel,","placement","plan","platform.","pleas","practic","preference.","print(\"deveui:","prior","produc","protocol","protocol.","pycom","recommend","regist","registered,","registr","registration.","requir","retriev","right","router","router.eu.thethings.network).","run","screen","select","semtech","send","server","set","settings.","settings:","setup","showing.","similar","specif","specifi","standard","step","tab","tab.","thing","this,","this.","tick","to.","top","ttn","ttn.","two","ubinascii","udp","under","uniqu","up","us","user","usernam","valu","verifi","way","websit","well","wifi","wl","wlan","wlan()"],"gettingstarted/registration/lora/senet.html":["#","%","%s\"","(abp).","(appeui)","(appkey)","(between","(call","(deveui)","(in","(otaa)","(over","(the","(ubinascii.hexlify(lora.mac()).decode('ascii')))","1.0.x","10","5","64","=","abp","access","account","activ","activated,","activation)","activities.","addit","adr=true,","air","alway","app_eui","app_key","app_key),","appeui","appkey)","appkey.","applic","asia","attempt","australia","auth=(app_eui,","authent","avail","backend","backend).","basi","begin","bit","both","broker","case","cases,","choic","code","come","complet","complete,","configur","connect","consist","creat","custom","datagram","detail","develop","deveui)","devic","device!","device'","device.","device:","docs.","document","dr=0,","dure","each","element","end","environments,","eui","europ","fact","factori","fipi","first","follow","form","formats.","free","gateway","gateway,","gener","global","grant","hexadecim","ident","identifi","identifier.","import","inform","initi","initialis","integrity.","interog","itself","join","key","line","lopi","lopy:","lora","lora()","lora(mode=lora.lorawan,","lora.as923","lora.au915","lora.eu868","lora.init(mode=lora.lorawan,","lora.join(activation=lora.otaa,","lora.mac().to","lora.us915","lorawan","manufactur","match","messag","mode.","narrow","need","network","network.","now","obtain","onboard","onc","oper","optim","otaa","over","paramet","person","pick","pleas","portal","portal,","portal.","present","print(\"deveui:","privaci","process","process.","product","provid","provis","provisioning.","public","public=true)","readi","region","region=lora.us915)","regist","registr","registration.","represent","requir","run","screen.","secret","secur","send","senet","server","server)","servic","session","set","share","sign","socket","standard","start","state","step","stream","support","terminology)","three","through","time","timeout=0)","tutori","two","typic","ubinascii","ubinascii.unhexlify('00112233445566778899aabbccddeeff')","ubinascii.unhexlify('00250c0000010001')","unavailable.","uniqu","unique,","unit","up","us","valu","varieti","veri","walk","want"],"gettingstarted/troubleshooting-guide.html":["$user","&","(1.19.0","(apm","(apm)","(e.g.","(for","(lowercase)","(use",".atom\\packages\\pymakr\\","/","1.","1.0)","1.2.5,","2","2.","2.7:","2.x.","3.","3.0","3.x,","32","64","7.8.0",">>",">>>","access","alloc","alreadi","alway","amount","apm","appear","applic","ask","atom","atom/vscod","back","befor","binascii","binascii.hexlify(machine.unique_id())","bind","bit","board","board,","boot","bootload","button","c","cabl","can't","capit","case","cases,","caus","check","checksum.","code","code,","code.","code:","command","compat","compil","comput","confirm","connect","consol","contain","ctrl","current","depend","detail","develop","devic","dialout","document","doesn't","echo","empti","end","ensur","error","error,","exampl","exit","expans","extens","fail","failed,","file","find","fipi","firmwar","firmware,","folder","folder.","folder:","follow","forum?","g","give","guid","gyp","happen","help","help.","higher)","import","includ","insid","instal","install.","installed.","instead.","issu","latest","lib)","librari","linux","load","locat","look","loop/non","lose","machine,","machines,","make","manag","memory,","memory.","memory'","mode","mode.","modul","module'","name","need","node","nodej","nodejs.","normally,","now","number","nvm","nvm).","occur","old","older","open","oper","os.uname()","packag","package:","permiss","plug","plugin","plugin.","port.","precompil","press","previou","proceeding:","process","project","prompt","provid","put","pycom","pymakr","pymakr@1.0.3)","python","pytrack,","re","reason,","recognis","reinstal","releas","rememb","remov","renam","repl","repl.","reset","result","revert","run","run/sync","safe","save","script","script,","script/program","send","sensor)","separ","serial","serialport","setup","sha1","shields,","similar","solution:","start","stuck","substanti","sudo","support","sure","switch","synchronis","system","system.","system'","take","tell","termin","this,","ticket","time.","traceback","tri","troubleshoot","type","understand","unexpect","uninstal","updat","updater.","upgrad","upgrade.","upload","us","usb","user","usermod","using.","version","versions.","via","vscode","window","within","wrong","you'r","you'r","~/.atom/.apm/pymkr","~/.atom/.apmrc","~/.atom/packages/pymakr","~/.config/atom/cach","—version","‘fail","‘serialport'","“python=/usr/bin/python2.7”","“p”","“x\""],"pymakr/installation/":["avail","built","call","develop","easi","editors,","follow","instal","make","platforms:","plugin","popular","possibl","pycom","pymakr","pymakr.","text","two"],"pymakr/installation/atom.html":["\"connect","&","(the","192.168.4.1","2.0,","3.0",">",">>>,","^","abov","access","additionally,","address","address.","appears.","appli","arrow","atom","atom.","automat","basi","befor","beginners,","between","board","button","button,","button.","cables,","click","click,","clipboard.","comput","configur","connect","consol","copi","correctli","default","desir","devic","don't","download","e.g.","earlier","easiest","edit","editor","ensur","enter","etc.).","expans","extern","few","field","file","finish","firmwar","first","follow","ftdi","g23","get","global","gnd","help","host","indic","instal","installed.","interface.","it!","json","locat","lopi","lower","manually.","messag","micro","micropython","more","name","navig","need","note:","now","offici","open","open.","page,","pane,","password","past","per","pleas","plugin","plugin,","plugin.","plugin:","point","ports.","prefer","press","process","product","project","pycom","pymakr","python,","pytrack/pysens","recommend","remov","reset","respectively.","right","search","second","section","see","select","selected.","serial","set","settings.","show","side","ssid","start","step","steps:","such","sure","take","telnet","telnet.","text","that'","three","time","turn","upgrade,","us","usb","usb\"","usb.","use.","user","usernam","users,","via","well","wifi","window.","wipi","wire","wlan","www.pycom.io.","xxxx,","you'v"],"pymakr/installation/vscode.html":["\"connect","(the","192.168.4.1","5th",">",">>>,","abov","access","additionally,","address","address.","again","appear.","appears,","appears.","appli","arrow","auto","automat","avail","basi","befor","between","board","board,","bottom","button","button.","cables,","click","clipboard.","close","code","code,","code.","command","commands,","comput","configur","connect","connect,","consol","copi","correct","correctli","current","default","desir","detect","devic","device.","download","e.g.","earlier","easiest","edit","ensur","enter","etc.).","expans","extens","extension:","extern","extra","few","field","file","file,","file.","final","finish","firmwar","first","follow","ftdi","g23","global","gnd","host","id","indic","instal","installed.","interface.","it!","it.","json","latest","left","list","lopi","lt","manual","manually.","messag","micro","microsoft'","minutes,","name","navig","need","next","nodej","now","onc","open","open.","page,","password","past","pc.","per","platform","pleas","plugin","plugin,","plugin.","point","port","port.","ports.","press","process","product","project","project.","pycom","pymakr","python,","pytrack/pysens","reload","remov","reset","respectively.","save","search","second","section","see","selected.","serial","set","settings.","show","ssid","step","steps:","studio","such","support","sure","take","telnet","telnet.","that'","three","time","turn","upgrade,","us","usb","usb\"","usb.","use,","use.","usernam","version","via","visual","vs","vscode","vscode.","website.","wifi","window","wipi","wire","within","wlan","www.pycom.io.","xxxx,","you'v"],"pymakr/toolsfeatures.html":["\"/dev/cu.usbseri","\"address\":","\"micro\",","\"password\":","\"python\",","\"scripts\"","\"sync_folder\":","\"username\":","#","&","(current","(read","(repl)","(thi",".pi","ab001234\",","above,","access","addit","address","address/credentials,","adjust","again.","allow","ap","automat","avail","awar","begin","behaviour).","below","below:","blink","blue","board","boot","both","button","button.","call","caught","cert","certif","chang","click","close","code","code,","code.","coding,","colour","colour.","configur","connect","consol","console.","content","control","creat","default","demonstr","desir","devic","device,","device.","directli","directory.","disabl","display","editor'","ensur","enter","evalu","exactli","exampl","example,","exist","exit","featur","feature,","feature.","features.","file","files.","firmwar","folder","folder,","follow","function","functionality.","go","green","happen","here","hex","highest","ignor","import","indent","instance.","interact","known","led","level","lib","librari","light","line","line).","line.","live","local","loop,","loops.","made","main","make","micropython","modul","more","name","need","new","note","now","off/on","on.","one,","onto","open","open)","option","order","out","output","past","perman","place","plugin","point","port","power","pre","press","print","print()","project","projects,","push","pycom","pycom.heartbeat(false)","pycom.rgbled(0x00ff00)","pycom.rgbled(0xff0000)","pymakr","pymakr.conf","pymakr.conf.","python","read.","red","repl","repl.","restart","result","retriev","return","rgb","run","same","save","script","scripts.","see","serial","set","settings.","shown","specif","ssid","standard","start","step","store","structur","structure:","such","support","sync","sync.","take","tell","test","three","time","tool","tools/featur","type","up","upload","upon","us","user","valu","value.","variabl","variable.","variou","version","well","wifi","within","won't","write","written","{","}"],"pymakr/settings.html":["(e.g","(e.g.","(telnet)","/dev/cu.usbseri","1.17.0.b1","192.168.4.1","address","address,","ap","avail","befor","below","blank,","c","caus","click","code","com1","connect","consol","creat","ctrl","ctrl_c_on_connect","current","default","descript","devic","directori","dq0054e","editor","end","extens","featur","file","find","firmwar","higher.","ignor","ignored.","improv","include:","insid","ip","issu","json,","left","linux/macos)","list","log,","lot","micro.","mode","modul","module).","need","open","open_on_start","opened.","other","password","password,","perform","port","procedure.","process.","project","provid","py,","pycom","pymakr","pymakr.","python.","ram","reboot","reliabl","run","safe","safe_boot_on_upload","script","sent","serial","set","signal","specified,","started,","stop","sync","sync_file_typ","sync_fold","synced,","telnet,","telnet.","therefor","to.","tri","true,","txt,","upload","upload.","uploading.","us","user","usernam","username,","variou","version","via","want","window","xml"],"pytrackpysense/introduction.html":["&","(bq24040","(l76","(lis2hh12)","(ltr","(mfrc63002hn)","(mpl3115a2)","(scl).","(sda)","(si7006","(~1ua","01)","3","329al","a20)","acceleromet","addit","altimet","ambient","applic","applications,","asset","axi","barometr","batteri","below","board","board,","boards,","build","card","charger","charger.","chip","connect","connector)","datasheet","datasheets.","deep","detail","devic","digit","each","enabl","environ","expans","featur","find","fulli","function","glonass","gp","gpi08","gpi09","gps,","hardwar","hardware,","here:","humid","i2c","ideal","includ","info","intend","interface.","introduct","iot","jst","l)","light","list","locat","low","microsd","monitoring,","monitoring.","more","nfc","number","offer","oper","p21","p22","pack","pin","power","pressur","pycom","pyscan","pysens","pytrack","quickli","reader","readers.","rfid","rfid/nfc","scan","see","sens","sensing.","sensor","sensor,","sensors.","serial","sleep)","solution!","specif","such","support","temperatur","temperature,","three","track","tracking,","ultra","us","usb","varieti","version","via","whether"],"pytrackpysense/installation/":["added,","addit","be","check","develop","devic","ensur","essenti","featur","features/functionality.","file","firmware,","frequent","github","go","import","includ","instal","librari","pytrack/pysense/pyscan.","repositori","respect","softwar","updat","updated,","week,","well"],"pytrackpysense/installation/firmware.html":["#0","$","(0xf013","(0xf014for","(cdc)","(e.g:","(f013","(f014","(must","(normal","(on","(updat","...","0","0.9","004:","005:","0100","020","04d8","04d8:f013","04d8:f014","0x04d8.","0xef37","0xef38","0xef98","0xef99","0xf011","0xf012","0xf013","0xf014","1","1.","100%","16384","2005","2009","2010","2016","64","7","8","=","?!?","[=========================]","absolut","activ","alloc","allow","alreadi","altern","alway","appear","applic","approxim","apt","arch:","befor","below","below,","below:","board","boot","bootload","both","bottom","brew","bu","bug","button","button)","button.","byte","cabl","capabl","case,","case.","cdc","check","claim","click","com","command","command,","comput","computer.","condit","connect","connector.","console.","continu","copi","copyright","correctly.","d","data","debian:","debug","depict","determin","devic","device...","dfu","dfu,","dfuidle,","directori","directory).","disconnect","done!","done.","doubl","down","download","driver","driver,","driver.","drivers,","each","either:","enter","error","exemple,","expans","f014","fedora:","file","file:","firmwar","first","follow","free","harald","held","here","hold","homebrew:","host","http://sourceforge.net/p/dfu","id","if,","immediately.","inc.","instal","installation:","instructions.","interface...","keep","latest","libusb","libusbk","link","linux","linux:","lsusb","maco","macports:","match","mean","message,\"done!\"","microchip","mistake,","mode","mode)","mode,","mode.","mode:","modes.","navig","need","normal","normal,","note:","on","open","openmoko","output,","pacman","partit","password.","pc","pid),","pleas","plug","port","port,","present","press","procedur","product","program","prompt","prompt.","pyabcde0","pyscan","pysens","pysense),","pysense).","pysense/pytrack/pyscan/expans","pysense_x.x.x.dfu","pytrack","pytrack,","pytrack/pysens","pytrack/pysense,","pytrack:","pytrack_0.0.8.dfu","pytrack_0.0.8.dfu):","releas","repeat","repl","replac","report","requir","required.","reset","return","run","runtim","s1","same","schmidt","schmidt,","second","seconds,","seconds.","see","select","serial","serial:","set","shield","similar","size","softwar","specif","state","state(2)","static.ex","statu","status(0)","status:","stefan","step","steps:","success","successful,","sudo","sudo.","sy","technolog","termin","the“instal","time","tool","tool,","tormod","transfer","ubuntu","unplug","unsuccessful,","up","updat","upload","upon","us","usb","util","util.","util/tickets/","util:","v0.9","v3","v3,","vendor","verifi","version","via","visibl","volden","wait","warning:","warranti","welt","weston","window","x.x.x","yum","zadig","–"],"pytrackpysense/installation/drivers.html":["(e.g.",".zip","3","7","7,","8/10/+,","anyway","back","befor","below","below.","board","box","brows","can't","click","comput","confirm","contained.","correct,","correctli","devic","devices.","download","driver","driver.","drivers.","dropdown","extract","file,","first","folder","folder).","folder.","follow","gone","haven't","instal","installed.","instruct","label","link","linux.","maco","manag","manager.","menu","navig","need","next","now","offici","open","option","out","pleas","point","publish","pysens","pytrack","pytrack/pysens","pytrack/pysense/pyscan/expans","receiv","requir","right","search/navig","see","select","softwar","software.","specifi","start","successful,","suggest","support","under","updat","us","verifi","warn","warning,","well","window","work"],"pytrackpysense/installation/libraries.html":["(lopy,","(pysense/pytrack),",".pi",".zip","/lib","2.0,","=","_lib/pycoproc_","acceleromet","access","add","addit","api.","archive.","be.","behav","below.","board","board.","code","correct","desir","devic","device'","device,","device.","download","enabl","etc.)","exactli","example,","expans","extract","few","file","file,","folder","folder:","follow","found","github","import","importing/us","insid","instal","instruct","latest","librari","libraries,","library.","light","lis2hh12.pi","lt","ltr329als01","ltr329als01(py)","ltr329als01.pi","make","mani","micropython","modul","navig","need","onc","page.","place","plugin,","print(lt.light())","process","process.","py","pycom","pycoproc.pi","pymakr","pysens","pysense()","pysense,","pysense.pi","pysense:","pytrack","read","releas","repositori","required.","resid","run","same","sensor","sensor,","sipy,","specif","standard","to/from","typic","under","upload","upload,","us","used/import","user","utilis","variou","version","via","wipi","wish","written"],"pytrackpysense/apireference/":["abstract","api","away","created,","follow","interact","level","librari","low","next","page","pyscan.","pysense,","pytrack,","refer","respect","sensors.","simplifi","usability,"],"pytrackpysense/apireference/pytrack.html":["'p21')","'p21',","'p22',","(g).","(in","(lis2hh12)","(none,","(quectel","(with","180","180.","3","90","90.","=","acceler","acceleration,","acceleromet","ad","avail","available,","axi","be","beyond","board","board.","chapter","class","construct.","constructor","contribut","coordin","creat","current","debug","degre","describ","design","detail","due","each","exact","expired,","false)","featur","feel","float","found","free","function","github","glonass","glonass)","gnss)","gp","i2c","includ","inform","know","l","l76","l76gnss","l76gnss(pytrack","l76gnss.","l76gnss.coordinates(debug","lack","latitud","latitude.","librari","libraries.","lis2hh12","lis2hh12(pytrack","lis2hh12.","lis2hh12.acceleration()","lis2hh12.pitch()","lis2hh12.roll()","location.","lock","lock.","longitud","longitude/latitude,","make","measurement,","method","more","none)","none).","none,","note","object","object,","onc","orient","output","pass","period","pitch","pleas","possibl","provid","pull","pytrack","pytrack'","pytrack'","rang","read","repeat.","repositori","request","requir","return","roll","roll,","scl","sda","search","seconds)","sensors.","set","speed","successfulli","tilt","time","timeout","true","tupl","valu","variou","verbose.","weekli","well","yaw","yaw."],"pytrackpysense/apireference/pysense.html":["'p21')","'p21',","'p22',","(%)","('c).","(g).","(lis2hh12)","(ltr","(m)","(m).","(mpl3115a2)","(pa),","(pa).","(si7006a20)","01)","180","180.","3","329al","90","90.","=","acceler","acceleration,","acceleromet","ad","addit","als_gain_1x,","als_gain_1x,als_gain_2x,","als_gain_48x,","als_gain_4x,","als_gain_8x,","als_gain_96x","als_int_100,","als_int_150,","als_int_200,","als_int_250,","als_int_300,","als_int_350,","als_int_400","als_int_50,","als_rate_100,","als_rate_1000,","als_rate_200,","als_rate_2000","als_rate_50,","als_rate_500)","als_rate_500,","altimet","altitud","ambient","argument","atmospher","avail","available,","axi","barometr","be","beyond","board","board.","both","chapter","class","construct.","constructor","constructor.","contribut","creat","current","datasheet","degre","describ","design","detail","digit","dual","due","each","exact","extern","featur","feel","float","follow","free","function","gain","gain:","github","humid","humidity.","i2c","includ","inform","integr","integration:","know","lack","level","librari","libraries.","light","lis2hh12","lis2hh12(pysens","lis2hh12.","lis2hh12.acceleration()","lis2hh12.pitch()","lis2hh12.roll()","ltr329als01","ltr329als01(pysens","ltr329als01.light()","lux.","make","measurement,","method","mode","mode:","more","mpl3115a2","mpl3115a2(pysens","mpl3115a2.","mpl3115a2.altitude()","mpl3115a2.pressure()","mpl3115a2.temperature()","none,","note","object","object,","onc","orient","output","pass","percentag","pitch","pleas","possibl","pressur","pressure)","pressure,","provid","pull","pysens","pysense'","rang","rate","rate:","read","rel","repeat.","repositori","request","requir","return","roll","roll,","scl","sda","see","sensor","sensor.","sensors.","si7006a20","si7006a20(pysens","si7006a20.","si7006a20.humidity()","si7006a20.temperature()","successfulli","temperatur","temperature.","tilt","tupl","two","valu","variou","wavelength","weekli","well","yaw","yaw."],"pytrackpysense/apireference/pyscan.html":["'p21')","'p21',","'p22',","(4,","(atqa),","(g).","(lis2hh12)","(ltr","(mfrc6300)","(mfrc630_mf_auth_key_a","0","01)","10),","16","180","180.","3","329al","6","7,","90","90.","=","acceler","acceleration,","acceleromet","accord","activ","ad","als_gain_1x,","als_gain_1x,als_gain_2x,","als_gain_48x,","als_gain_4x,","als_gain_8x,","als_gain_96x","als_int_100,","als_int_150,","als_int_200,","als_int_250,","als_int_300,","als_int_350,","als_int_400","als_int_50,","als_rate_100,","als_rate_1000,","als_rate_200,","als_rate_2000","als_rate_50,","als_rate_500)","als_rate_500,","alway","ambient","answer","answer.","appear","appropri","argument","around","array","array.","authent","authenticated,","authentication.","avail","available,","axi","b","be","beyond","bit","block","block)","block_address","board","board.","both","buffer","buffer.","byte","byte,","call","card","card'","card,","card.","case","chapter","check","checking.","class","collis","command","command.","construct.","constructor","constructor.","contribut","convert","creat","crypto1","current","data","datasheet","debug","debug=false)","degre","describ","design","dest","dest)","detail","determin","devic","device.","digit","disabl","discov","dual","due","each","enabled.","encryption.","error","exact","explain","extern","failure,","failure.","featur","feel","first","float","follow","format","format,","format.","four","free","function","gain","gain:","github","handl","hexadecim","higher","hold","i2c","identifi","idl","includ","inform","initialis","instruction:","integr","integration:","iso14443a,","key","key,","key_typ","key_type,","know","lack","len","len)","length","length)","length.","level","librari","libraries.","light","lis2hh12","lis2hh12(pysens","lis2hh12.","lis2hh12.acceleration()","lis2hh12.pitch()","lis2hh12.roll()","load","long","ltr329als01","ltr329als01(pysens","ltr329als01.light()","lux.","make","manual","measurement,","memori","method","method.","mf","mfrc630","mfrc630(pyscan=none,","mfrc630.format_block(block,","mfrc630.mfrc630_cmd_idle()","mfrc630.mfrc630_cmd_init()","mfrc630.mfrc630_cmd_load_key(key)","mfrc630.mfrc630_cmd_load_key(key).","mfrc630.mfrc630_cmd_reset()","mfrc630.mfrc630_format_block(data,","mfrc630.mfrc630_iso14443a_select(uid)","mfrc630.mfrc630_iso14443a_wupa_reqa(instruction)","mfrc630.mfrc630_mf_auth(uid,","mfrc630.mfrc630_mf_deauth()","mfrc630.mfrc630_mf_read_block(block_address,","mfrc630.mfrc630_print_block(data,","mfrc630.print_debug(msg)","mfrc630_format_block","mfrc630_iso14443_cmd_reqa","mfrc630_iso14443_cmd_wupa,","mfrc630_mf_auth_key_b)","mfrc630_mf_deauth()","mifar","mode.","more","multipl","nfc","none,","nonzero","norm.","note","number","object","object,","object.","occur,","onc","orient","otherwis","output","pass","perform","pitch","pleas","possibl","present,","print","procedur","procedure.","provid","pull","pyscan","pyscan'","pysens","rang","rate","rate:","read","received.","regist","register.","repeat.","repositori","reqa.","request","requir","reset","respons","result","return","roll","roll,","scl","scl='p21',","sda","sda='p22',","see","select","send","sensor","sensors.","separ","set","space","statement","statu","stop","store","succeeded.","success.","successfulli","tilt","timeout","timeout=none,","tri","tupl","two","uid","uid.","uid:","us","valu","variou","wavelength","weekli","well","whether","wrapper","write","wupa","yaw","yaw."],"pytrackpysense/apireference/sleep.html":["\"","#","#from","#pi","(2g)","(accelerometer,","(activ","(class","(express","(inact","(pic","(pin#6","(wakeup)","+","1","2","200)","2000mg","200m","4","5","8","=","abov","acc","acc.enable_activity_interrupt(2000,","acceler","acceleromet","activ","activity/inact","actual","ad","although","and/or","appropri","approxim","are:","asynchron","avail","available,","awoken","be","begin","board","boolean","both","buttom","button)","call","callback","certain","chapter","class,","code","code,","configur","configured.","contribut","default","describ","detect","detection)","display","durat","duration,","duration.","dure","edg","edge.","embed","enabl","event","exampl","example,","executed,","extern","fall","falling])","featur","feel","find","follow","found","free","function","function,","github","go","go_to_sleep()","gp","handler","happen","header)","header).","import","inact","indic","instantiated.","int","interrupt","interrupts,","interv","interval,","interval.","io","it'","last","librari","libraries.","lis2hh12","lis2hh12()","lis2hh12)","manual","maximum","method","method.","methods,","micropython","micropython.","min","minut","mode,","more","next","normal","note","note:","option","out","out.","paramet","pic","pic_rc1","pin","pin#6","pleas","possibl","previous","print(\"approxim","print(\"wakeup","pull","put","py","py.go_to_sleep()","py.setup_int_pin_wake_up(false)","py.setup_int_wake_up(true,","py.setup_sleep(300)","pysens","pysense()","pysense,","pytrack","pytrack()","pytrack.get_sleep_remaining()","pytrack.get_wake_reason()","pytrack.go_to_sleep([gps=true])","pytrack.setup_int_pin_wake_up([rising_edg","pytrack.setup_int_wake_up(rising,","pytrack.setup_sleep(time_seconds)","pytrack.setup_sleep(timout_sec).","pytrack/pysens","quick","ra5).","rc1,","reason","reason.","reason:","remain","remaining:","repositori","request","requir","reset","restart","return","rise","same","script,","sec\")","second","seconds)","seconds.","session","set","set,","setup_sleep()","sleep","sleep.","snippet:","sourc","source,","specifi","start","state","str(py.get_sleep_remaining())","str(py.get_wake_reason()))","threshold","time","time.sleep(0.5)","timeout","toggled.","true)","true])","us","usag","user","valu","variou","wake_reason_acceleromet","wake_reason_int_pin","wake_reason_push_button","wake_reason_tim","wakeup","weekli"],"tutorials/introduction.html":["along","befor","bluetooth,","boards.","code","connect","contain","control","devic","device,","ensur","etc.","exampl","expans","final","firmwar","firmware;","found","gener","i/o","instruct","introduct","later","latest","librari","lopi","lora","modul","network,","network.","node","pin","pycom","pysense.","pytrack","relat","repository.","requir","run","section","see","set","sigfox","sipi","sourc","specif","starting,","such","tutori","tutorials,","up","updates.","us","wifi"],"tutorials/all/":["boards.","contain","devic","exampl","expans","gener","pycom","section","work"],"tutorials/all/repl.html":["\"help()\"","'py'","'pypypypypypypypypypypypypypypypypypypypy'","(power","(putty,","(the","*","+","/","1","10","146","2","2.5","20","2016","21;","3","5","=",">>>",">>>.","above,","above.","appear","appear,","appear:","basic","below.","black","blank","button","charact","command","connect","connecting,","ctrl","cursor.","d","devic","device'","device.","disconnect","end","enter","enter,","esp32","etc).","exampl","example,","fashion.","features:","first","flash","following,","g1d8b5e5","goe","hard","hardwar","hello","here","i.e.","ident","import","indic","information.","isn't","led","led(0)","led(1)","led).","led.toggle()","let'","lopi","lopy!","lopy!\")","machin","make","message,","methods.","micropython","mode=pin.out,","more","next","obligatori","off/on)","onc","open","out","output","perform","picocom,","pin","pin('g16',","place","plugin,","press","print(\"hello","program","prompt","prompt,","prompt.","pyb:","pycom","pymakr","python","reboot","repl","reset","reset.","reset;","rgb","rst","screen","screen,","see","serial","session,","similar","small","soft","someth","still","sure","switch","telnet,","termin","test","test:","text","tri","two","type","typed.","upon","us","utilis","v1.4.6","value=1)","work","working,","wrong,"],"tutorials/all/wlan.html":["!=","\"+net_to_use+\"","#","&","'',","'':","''},","'10.0.0.1')},","'10.0.0.1',","'192.168.178.1',","'255.255.0.0',","'255.255.255.0',","'8.8.8.8'))","'mywifi':","'mywifikey'),","'password'),","'username',","'wlan_config'","'wlan_config':","('10.0.0.114',","(chain)","(ip,","(or","(sec,","(wlan.ap","+","/flash/boot.py:","/flash/cert.","115200)","=","==",">>>","[e.sec","address","address,","address:\"","alway","antenna=wlan.int_ant)","ap","appropri","around","assign","auth=(net.sec,","auth=(wlan.wpa2,","auth=(wlan.wpa2_ent,","auth=(wlan.wpa2_ent,),","auth=original_auth,","automat","available_net","available_nets])","befor","below","below,","boot","boot.pi","break","broken.","ca","ca_certs='/flash/cert/ca.pem')","ca_certs='/flash/cert/ca.pem',","call","case","caus","certfile='/flash/cert/client.crt')","certif","chang","channel=6,","check","class","client","code","command","configur","connect","connecting,","connection.","constructor","copi","crucial","current","default.","devic","device,","devices,","dns_server)","duplic","dure","e","e.g.","e.ssid","e:","eap","enabl","enterpris","except","execut","exist","featur","file","fix","follow","found!')","frozenset([e.ssid","frozenset([key","gateway,","get","go","hold","home","identity='myidentity',","import","instance,","instruct","interact","ip","key","key,","keyfile='/flash/cert/client.key',","known","known_net","known_nets[net_to_use]","known_nets])","known_nets_nam","known_nets_names)","line","list","list(net","locat","lopi","machin","machine.idle()","machine.reset_cause()","machine.soft_reset:","machine.uart(0,","match","mean","mode","mode\")","mode,","mode;","multipl","necessary,","net","net.ssid","net_properti","net_properties:","net_properties['pwd']","net_to_us","net_to_use[0]","net_to_use][0]","nets\")","nets:","network","network,","networks:","notic","now","object,","obtain","option","order","original_auth","original_ssid","os","os.dupterm(uart)","over","pair.","param","password","peap","power","print(\"connect","print(\"fail","print(\"scan","print('network","print('wlan","privat","proce","provided.","public","put","pwd","pwd),","pycom","repl","requir","reset","reset.","retriev","router","run","run:","running:","save","scan","script","sec","secur","serial","server'","session","set","settings!!","setup","soft","ssid,","ssid=original_ssid,","static","station:","status,","subnet_mask,","succeeded!')","system","telnet","therefor","this:","timeout=10000)","timeout=5000)","tls:","try:","ttls),","ttls:","two","uart","uart.","under","up","up)","up,","upon","us","usb.","user","usernam","valid","via","wait","way","wifi","wifi.","without","wl","wl.auth()","wl.connect(net_to_use,","wl.ifconfig()[0])","wl.ifconfig(config=net_properties['wlan_config'])","wl.init(mode=wlan.ap,","wl.isconnected():","wl.mode(wlan.sta)","wl.scan()","wl.ssid()","wlan","wlan()","wlan(mode=wlan.sta)","wlan.ap","wlan.connect('mywifi',","wlan.connect(net.ssid,","wlan.connect(ssid='mywifi',","wlan.ifconfig(config=('192.168.178.107',","wlan.init(mode=wlan.sta)","wlan.isconnected():","wlan.mode()","wlan.scan()","wlan_config","wpa2","{","{'pwd':","}"],"tutorials/all/ble.html":["#","%","%x'","&","'heart","(apple'","(char.properties()","1)","10","=","==","addr","adv","adv:","advertis","advertisements.","advertiser.","again","api","around","attempt","available.","basic","ble","bluetooth","bluetooth()","bluetooth.adv_manufacturer_data)","bluetooth.adv_name_cmpl)","bluetooth.adv_name_cmpl))","bluetooth.connect(adv.mac)","bluetooth.get_adv()","bluetooth.isscanning():","bluetooth.prop_read):","bluetooth.resolve_adv_data(adv.data,","bluetooth.start_scan(","bluetooth.start_scan(10)","bluetooth.start_scan(20)","bluetooth.stop_scan()","break","bt","bt.connect(adv.mac)","bt.get_adv()","bt.resolve_adv_data(adv.data,","bt.start_scan(","bytes:","call","char","char.read()))","chars:","complet","conn","conn.disconnect()","conn.services()","connect","continu","data","devic","device.","else:","exampl","except:","featur","features.","firmwar","found","full","function","future,","here)","ibeacon","implement","import","indefinit","info","it'","line","manufactur","mfg_data","mfg_data:","more","name","near","network","none","page","pairing.","pass","present,","print","print(\"connect","print('char","print('read","print(bluetooth.get_adv())","print(bluetooth.resolve_adv_data(adv.data,","print(ubinascii.hexlify(mfg_data))","quick","rang","rate'","rate':","raw","receiv","reference.","resolve_adv_data()","retriev","scan","second","send","sent","servic","service.characteristics()","service.uuid())","services.","services:","start","stop","such","time","time.sleep(0.050)","timeout","tri","true:","try:","type(service.uuid())","ubinascii","until","updat","us","usag","valu","within","{}","{}\".format(ubinascii.hexlify(adv.mac)))","{}'.format(char.uuid(),","{}'.format(service.uuid()))"],"tutorials/all/https.html":["/flash/cert/","1])","443)[0][","8441)[0][","=","api","basic","below","blynk","ca_certs='/flash/cert/ca.pem')","cert_reqs=ssl.cert_required,","certif","check","cloud.","connect","device.","download","exampl","folder","http","import","info,","modul","more","place","reference.","s","socket","socket.socket()","ss","ss.connect(socket.getaddrinfo('cloud.blynk.cc',","ss.connect(socket.getaddrinfo('www.google.com',","ssl","ssl.wrap_socket().","ssl.wrap_socket(s)","ssl.wrap_socket(s,","us"],"tutorials/all/mqtt.html":["\"io.adafruit.com\",user=\"your_username\",","\"wifipassword\"),","=","account.","adafruit","adafruit'","allow","api","auth=(wlan.wpa2,","broker","broker.","client","client.check_msg()","client.connect()","client.publish(topic=\"youraccount/feeds/lights\",","client.set_callback(sub_cb)","client.subscribe(topic=\"youraccount/feeds/lights\")","creat","credentials.","data","def","devic","exampl","free","functionality.","guid","hold","ideal","import","inform","io","iot","key","lightweight","machin","machine.idle()","messag","more","mqtt","mqtt.","mqttclient","mqttclient(\"device_id\",","msg):","msg=\"off\")","msg=\"on\")","need","network","off\")","on\")","order","packet","password=\"your_api_key\",","platform,","port=1883)","print(\"connect","print(\"send","print(msg)","protocol","same","send","show","small","sub_cb(topic,","subscrib","time","time.sleep(1)","timeout=5000)","tinker","topic","topic,","true:","us","via","visit","well","wifi.","wifi\\n\")","wlan","wlan(mode=wlan.sta)","wlan.connect(\"yourwifinetwork\",","wlan.isconnected():","you'll"],"tutorials/all/aws.html":["\"","\")","\"accepted\":","\"deltalistener\"","\"mi","\"rejected\":","\"shadowecho\"","\"shadowupdater\"","\"timeout\":","#","#################","##################","#######################","########################","#client_id","#conn_disconn_timeout","#connect","#mqtt_oper_timeout","#thing_nam","'/flash/cert/aws_client.cert'","'/flash/cert/aws_private.key'","'/flash/cert/aws_root.ca'","'aws_host_url'","'my_wifi_password'","'my_wifi_ssid'","'publishtopic'","'pycompublishclient'","'to","'{\"state\":{\"desired\":{\"property\":'","'}}}'","(*.pem.crt)","(*.private.pem.key)","(amazon","(config.py):","(main.py)","(pycom","+","+=","/","/flash/cert","0","1","1)","1,","10","2","5","5)","8883","=","==","\\n\\n\")","accepted!\")","action","activ","all:","amazon","applic","attach","authorise.","aw","aws_client_cert","aws_host","aws_port","aws_private_key","aws_root_ca","awsiotmqttclient(config.client_id)","awsiotmqttshadowclient(config.client_id)","broker","button","button,","buttons.","ca","callback","certif","certificate,","certificates,","choos","click","client","client.","client_id","cloud","code","collect","common","config","config.aws_client_cert)","config.aws_port)","config.aws_private_key,","config.last_will_msg,","config.pi","configur","conn_disconn_timeout","connect","consol","contain","control","creat","custom","customcallback(client,","customcallback)","customshadowcallback_delete(payload,","customshadowcallback_delta(payload,","customshadowcallback_update(payload,","customshadowcallback_update,","def","delet","delta","detail","devic","device):","deviceshadowhandl","deviceshadowhandler.shadowdelete(customshadowcallback_delete,","deviceshadowhandler.shadowregisterdeltacallback(customshadowcallback_delta)","deviceshadowhandler.shadowupdate(jsonpayload,","diagram","doc","dot","download","draining_freq","echo","enabl","enter","file","file.","flash","folder.","forev","format,","ftp","function","gener","get","github","give","go","hand","host","imag","inform","interact","internet","iot","json","json.loads(payload)","jsonpayload","key","last","last_will_msg","last_will_top","latest","left","let","link","listen","loop","loopcount","main.pi","manag","messag","message'","message):","message:","messages,","more","mqtt","mqtt_oper_timeout","name","name\"","navig","need","new","offline_queue_s","out!\")","page,","pane,","path","paths.","payloaddict","pdf","platform","polici","press","print(\"","print(\"delet","print(\"from","print(\"property:","print(\"receiv","print(\"upd","print(\"version:","print('aw","print(message.payload)","print(message.topic)","privat","process","publish","put","pycom","pycomawsmqttcli","pycomawsmqttclient.configureconnectdisconnecttimeout(config.conn_disconn_timeout)","pycomawsmqttclient.configurecredentials(config.aws_root_ca,","pycomawsmqttclient.configuredrainingfrequency(config.draining_freq)","pycomawsmqttclient.configureendpoint(config.aws_host,","pycomawsmqttclient.configurelastwill(config.last_will_topic,","pycomawsmqttclient.configuremqttoperationtimeout(config.mqtt_oper_timeout)","pycomawsmqttclient.configureofflinepublishqueueing(config.offline_queue_size)","pycomawsmqttclient.connect():","pycomawsmqttclient.subscribe(config.topic,","pycomawsmqttshadowcli","pycomawsmqttshadowclient.configureconnectdisconnecttimeout(config.conn_disconn_timeout)","pycomawsmqttshadowclient.configurecredentials(config.aws_root_ca,","pycomawsmqttshadowclient.configureendpoint(config.aws_host,","pycomawsmqttshadowclient.configuremqttoperationtimeout(config.mqtt_oper_timeout)","pycomawsmqttshadowclient.connect():","pycomawsmqttshadowclient.createshadowhandlerwithname(config.thing_name,","register/manag","rejected!\")","remotely.","report","repository.","request","responsestatu","responsestatus,","root","sampl","secur","see","send","set","settings,","shadow","shown","side,","sign","specif","specifi","start","state","str(loopcount)","str(payloaddict[\"state\"][\"desired\"][\"property\"]))","str(payloaddict[\"state\"][\"property\"]))","str(payloaddict[\"version\"]))","subscib","subscrib","succeeded')","telemetri","thing","things.","three","time","time.sleep(1)","time.sleep(2)","time.sleep(5)","token","token):","token:","topic","topic:","topics.","true)","true:","up","updat","user","user.","userdata,","via","website):","wifi","wifi,","wifi_pass","wifi_ssid"],"tutorials/all/adc.html":["#","1.1v","1120.","=","abov","access","accur","adc","adc()","adc(0)","adc.","adc.channel(pin='p13')","adc.channel(pin='p16',","adc.vref(1100)","adc.vref_to_pin('p22')","adc_c","adc_c()","adc_c.value()","attn=adc.attn_11db)","calibr","check","code","connect","current","disconnect","down","e.g.","each","esp32'","exampl","extern","factory.","firstli","follow","import","inform","intern","it.","known","machin","mean","measur","millivolts,","module.","more","note","now","output","p22","pleas","print(adc_c.voltage())","read","refer","reference.","reset","sample.","see","set","simpl","source.","tell","time","to.","true","us","valu","voltag","voltmet","vref","wish"],"tutorials/all/i2c.html":["\"!bb\"","\"!bh\"","#","(((data[0]","(device_id","(len","(recv_data)","(wait","+=","0","0):","0.1","1","120m","2)","2):","200):","5","=","==",">",">=","__init__(self,","ad","addr","addr=0x23,","addr=i2c.scan()[0])","anoth","baudrate=100000)","bh1750fvi","bh1750fvi.bh1750fvi(i2c,","bh1750fvi.py.","bh1750fvi:","bytes([0x10]))","class","code","code,","connectivity,","const(120)","continuo","data","def","device.","device_id","device_id,","digit","driver","enabl","exampl","file","follow","i2c","i2c(0,","i2c,","i2c.","i2c.master,","import","library.","light","light_sensor","light_sensor.read()","light_sensor.read())","lora","lora(mode=lora.lora,","lora_confirm_format","lora_pkg_format","lora_sock","lora_sock.recv(64)","lora_sock.send(msg)","lora_sock.setblocking(false)","lux","machin","measurement_tim","measurement_time:","msg","name","network","period","period=150):","place","print(data)","pycom","pycom.heartbeat(false)","pycom.rgbled(0x001500)","pycom.rgbled(0x150000)","read","read(self):","receiv","recv_data","recv_data)","region=lora.eu868)","same","sampl","self.addr","self.i2c","self.i2c.readfrom(self.addr,","self.i2c.writeto(addr,","self.period","self.tim","self.valu","send","sensor","sensor.","simpl","socket","socket.sock_raw)","socket.socket(socket.af_lora,","start","statu","status,","struct","struct.pack(lora_pkg_format,","struct.unpack(lora_confirm_format,","time","time.sleep(0.1)","time.sleep(1)","tx_iq=true,","us","valu","wait","while(true):"],"tutorials/all/owd.html":["\"\"\"","#","#!/usr/bin/env","&","((l_rom[byte]","((~temp_read","(1","(8","(count_per_c","(crc","(temp_msb","*","+","+=","//","0","0:","0x01","0x01:","0x18","0x28:","0x7f","0x80","0xff)","1","1)","1.","100","25","64","65","8","=","==",">",">=",">>","[]","[rom]","^","__init__(self,","_search_rom(self,","assert","attach","avail","b","b:","basic","bit","break","bu","buf):","buf:","byte","byte)","bytearray","bytearray(8)","bytes).","bytes.","class","cmd_matchrom","cmd_readrom","cmd_searchrom","cmd_skiprom","collision,","complement","comput","connect","const(0x33)","const(0x55)","const(0xcc)","const(0xf0)","convert","count_per_c","count_remain","count_remain)","crc","crc8(self,","data","data):","data[6]","data[7]","data[i]","def","devic","devices.","diff","diff)","diff):","differ","disable_irq","disable_irq()","don't","driver","ds18b20","ds18x20","ds18x20(ow)","each","elif","else:","enable_irq","enable_irq(i)","error","explain","fals","fb_bit","fill","function.","github","half","high","import","l_rom","l_rom,","l_rom:","librari","line","list","machin","machine.disable_irq","machine.disable_irq()","machine.enable_irq","match","mean","micropython","next_diff","none,","now","object","onewir","onewire(pin('p10'))","onewire:","otherwise.","ow","p10","pass","perform","pin","pin()","pin(0)","pin(1)","pin):","pin.pull_up)","presenc","print(temp.read_temp_async())","pulse,","pycom","python3","r_b","range(0xff):","range(8):","range(len(data)):","read","read_bit(self):","read_byte(self):","repository.","reset","reset(self):","return","rom","rom):","rom,","rom0","rom:","scan(self):","select","select_rom(self,","self._search_rom(rom,","self.pin","self.pin.init(pin.open_drain,","self.read_bit()","self.read_bit():","self.reset()","self.reset():","self.write_byte(b)","self.write_byte(cmd_matchrom)","self.write_byte(cmd_searchrom)","self.write_bytes(rom)","sensor.","shift","shifting,","sleep_u","sleep_us(1)","sleep_us(40)","sleep_us(420)","sleep_us(480)","sleep_us(60)","specif","statu","talk","temp","temp.start_conversion()","temp_lsb","temp_read","temperatur","time","time.sleep(1)","time.sleep_u","to.","true","true:","truncat","tutori","two","two'","usag","valu","without","write_bytes(self,","|","|="],"tutorials/all/threading.html":["%","%d'","(i","+","1,","3","=","_thread","_thread.allocate_lock()","_thread.start_new_thread(th_func,","a_lock","a_lock:","below","def","defin","demonstr","differ","each","exampl","executes\")","follow","function","i))","id)","id):","import","interval.","lock","locks:","micropython","module.","number","on","parameters.","perform","print","print(\"a_lock","print('run","range(3):","receiv","simpli","spawn","started,","support","th_func(delay,","thread","time","time.sleep(delay)","true:","us"],"tutorials/all/rgbled.html":["#","10","4s","alive.","blue","code","colour","cycl","cycles.","default","detected.","error","expect","flash","follow","green","heartbeat","here","import","indic","led","light","make","module.","onc","overridden","piec","pycom","pycom.heartbeat(false)","pycom.rgbled(0x007f00)","pycom.rgbled(0x7f0000)","pycom.rgbled(0x7f7f00)","pycom.rgbled(0xff00)","range(10):","red","result:","rgb","run","signal","stop","system","through","time","time.sleep(1.5)","time.sleep(4)","time.sleep(5)","traffic","turn","us","yellow"],"tutorials/all/timers.html":["#","%","%f","(total","+=","0","1","1,","1.25","10","10:","=","==","__init__(self):","_seconds_handler(self,","alarm","alarm):","alarm.callback(none)","block","callback","chrono","chrono.read()","chrono.start()","chrono.stop()","chronomet","class","clock","clock()","clock:","code","code.","count","def","detail","done","elaps","even","exampl","example,","execut","finish","first","follow","found","good","handl","handling.","however,","import","inform","interrupt","interrupt.","interval.","it'","keep","lap","lap\"","lap)","lap))","last","machin","measur","mind","more","much","network","passed\"","periodic=true)","possibl","practic","print(\"","print(\"%02d","print(\"\\nth","print()","race\"","racer","read","request","restrict","second","seconds.","self.__alarm","self.second","self.seconds)","sequentially,","short.","simpl","simul","specif","stop","stopwatch.","time","time.sleep(1.25)","time.sleep(1.5)","timer","timer.","timer.alarm(self._seconds_handler,","timer.chrono()","took","total","total)","us","without"],"tutorials/all/pir.html":["!=","\")[1]","\"+net_to_use+\"","\"+self.basic+\"\\r\\n\\r\\n\")","\"+str(return_code))","#","#config","#flag","&","'',","'10.0.0.1')},","'10.0.0.1',","'255.255.0.0',","'networkid':","'utf8')","'wlan_config'","'wlan_config':","('10.0.0.8',","(boot.py)","(configur","(domoticz.py)","(main.py)","(sec,","+",",\"\")","/json.htm?\"+path+\"","0","10","115200)","1:","8080","=","==",">","[e.sec","__init__(self,","address:\"","antenna=wlan.int_ant)","ap","auth=original_auth,","available_net","available_nets])","basic","basic):","boot","case","channel=6,","class","code","command):","connect","constantli","d","d.setvariable('presence:livingroom','1')","def","detected,","domoticz","domoticz(\"\",","domoticz:","e","e.ssid","e:","else:","except","exception:","failed\")","frozenset([e.ssid","frozenset([key","go","high,","hold_tim","hold_time_sec","hold_time_sec:","http","http/1.1\\r\\nhost:","idx,","import","installation.","ip","ip,","keep","key","known","known_net","known_nets[net_to_use]","known_nets])","known_nets_nam","known_nets_names)","last_trigg","list(net","loop","loop\")","machin","machine.idle()","machine.reset_cause()","machine.soft_reset:","machine.uart(0,","main","mode\")","more","motion","name,","net","net_properti","net_properties:","net_properties['pwd']","net_to_us","net_to_use[0]","net_to_use][0]","nets\")","network","network,","original_auth","original_ssid","os","os.dupterm(uart)","path):","pin","pin('g4',mode=pin.in,","pir","pir()","port","port,","power","presence\")","print(\"connect","print(\"exit","print(\"fail","print(\"http","print(\"no","print(\"pres","print(\"request","print(\"scan","print(\"start","print(e)","pull=pin.pull_up)","pwd","pwd),","pycom.io\\r\\nauthorization:","read","request","request\")","result:","return","return_cod","s","s.close()","s.connect((self.ip,self.port))","s.send(b\"get","save","scripts,","sec","second","see","self.bas","self.ip","self.port","self.sendrequest(\"type=command¶m=switchlight&idx=\"+idx+\"&switchcmd=\"+command)","self.sendrequest(\"type=command¶m=updateuservariable&vtype=0&vname=\"+name+\"&vvalue=\"+value)","send","sendrequest(self,","sensor","setlight(self,","setvariable(self,","simpl","socket","socket.socket()","ssid=original_ssid,","statu","status.split(\"","step","str(s.readline(),","time","time.sleep_ms(500)","time.time()","timeout=10000)","trigger","trigger,","true:","try:","tutorial.","uart","value):","variable).","wait","wifi","wl","wl.auth()","wl.connect(net_to_use,","wl.ifconfig()[0])","wl.ifconfig(config=net_properties['wlan_config'])","wl.init(mode=wlan.ap,","wl.isconnected():","wl.mode(wlan.sta)","wl.scan()","wl.ssid()","wlan","wlan()","wlan(wlan.sta)","wrapper","{","{'pwd':","}"],"tutorials/all/modbus.html":["'","'.join('{:d}'.format(x)","'failure'","'success'","(modbu","(on/off)","+","/flash.","0","0.","0x00,","0x0000","0x01","0x02","0x03","0x04","0x05","0x06","0x0f","0x10","0xff00","1024]","125","2000","256,","32768","4,","6,","=","action","address","address,","analog","analogu","architecture.","array","avail","below.","between","code","codes.","coil","coil_quantity)","coil_quantity=100","coil_statu","coil_status))","coils,","command","commands,","commonli","commun","connect","content","contigu","continu","data","defin","deliv","descript","devic","device,","device.","discret","file.","first","folder","follow","found","ftp","function","github","here.","hold","independ","inform","input","input,","input_quantity)","input_quantity=100","input_statu","input_status))","intend","kind","librari","library,","list","master/slav","maximum","mean","medium","messag","modbu","modbus_obj.read_coils(slave_addr,","modbus_obj.read_discrete_inputs(slave_addr,","modbus_obj.read_holding_registers(slave_addr,","modbus_obj.read_input_registers(slave_addr,","modbus_obj.write_multiple_coils(slave_addr,","modbus_obj.write_multiple_registers(slave_addr,","modbus_obj.write_single_coil(slave_addr,","modbus_obj.write_single_register(slave_addr,","more","multipl","name","number","off.","on,","output","output_address,","output_address=0x00","output_flag","output_flag)","output_value)","output_value=0xff00","output_values)","output_values=[1,1,1,0,0,1,1,1,0,0,1,1,1]","over","packet","pdf","perform.","print('coil","print('hold","print('input","print('writ","protocol","pycom","python","quantiti","read","read.","regist","register_address,","register_address=0x01","register_quantity,","register_quantity=100","register_valu","register_value))","register_value,","register_value=","register_values,","register_values=[2,","registers.","remot","repository.","request","request.","request/repli","return_flag","rtu","rtu).","sampl","see","sequenc","serial","servic","set","shown","sign","signatur","signed)","signed=tru","singl","slave","slave_addr=0x0a","specifi","specified.","start","starting_address,","starting_address=0x0","starting_address=0x00","state","statu","status:","structur","support","target","tcp","tcp)","tell","transfer","transmiss","transmit","umodbu","up","upload","us","usual","valu","value,","value:","values,","via","write","written.","x"],"tutorials/all/ota.html":["\"1.0.1b\"","\"1095df8213aac2983efd68dba9420c8efc9c7c4a\"","\"ccc6914a457eb4af8855ec02f6909316526bdd08\"","\"delete\":","\"dst_path\":","\"firmware\":","\"flash/changed_file.py\",","\"flash/lib/new_lib.py\",","\"flash/old_file.py\",","\"flash/other_old_file.py\"","\"hash\":","\"host\"","\"http://192.168.1.144:8000/1.0.1b/flash/changed_file.py\",","\"http://192.168.1.144:8000/1.0.1b/flash/lib/new_lib.py\",","\"http://192.168.1.144:8000/firmware_1.0.1b.bin\",","\"new\":","\"over","\"update\":","\"url\":","\"version\":","#","(also","(becaus","(http://epydoc.sourceforge.net/stdlib/distutils.version.loosevers","(if","(ota)","(over","(thi","(via","(wait","/manifest.json?current_ver=1.0.0","0x02,","0x03]):","0x05,","0x06]))","1.0.0","1.0.1","100%","192.168.1.144:8000\\r\\n\\r\\n","2","5)","8000","8000)","=","==","[","],","abil","abov","achiev","activation)","actual","addit","address","agnost","air","air\"","allow","along","although","any...)","app_eui","app_key","app_key),","appimg.bin","appli","area","around","ask","asset_that_will_be_removed.wav","at:","auth=(app_eui,","avail","back","backup","base","be","befor","below","between","block","bluetooth","boot.pi","both","bring","broadcast","browser","build","bytes([0x01,","call","capabilities.","certain","chang","changed.","chosen","class","class.","class.html).","client","code","code,","come","command","comment","compani","compat","complet","config","connect","connect.","contain","content.","copi","correspond","creat","current","current_v","custom","data","delet","delete:","demonstr","deploy","describ","devic","device.","devices.","differ","directori","directory:","do.","downlink","e.g.","e.g:","end","entir","etc.","even","exampl","example)","example,","example.","exist","expect","expire)","explain","fails,","featur","fetch","field","fields:","file","file,","files,","files.","firmare_version.bin,","firmwar","firmware,","firmware.","firmware:","firmware_1.0.0.bin","firmware_1.0.1.bin","flash","follow","forever...)","format","found","from.","ftp.","full","function","functional,","gener","geograph","green","hash","header","here","here.","high","higher","highest","home","http","http/1.0\\r\\nhost:","http://127.0.0.1:8000/manifest.json?current_ver=1.0.0","hundr","imag","image.","imagin","implement","implemented.","import","incas","initi","initialis","instead","instruct","interfac","join","joined...')","json","latest","layer","layers.","leav","led","left","level","lib","lib_a.pi","librari","like:","limit","list","longer","look","loosevers","lora","lora(mode=lora.lorawan,","lora,","lora.","lora.has_joined():","lora.join(activation=lora.otaa,","lorawan","main.pi","make","manifest","manifest.json.","mechan","mechanism.","messag","message,","meter","meter.","method","method.","methodolog","micropyton","mode.","modul","name","need","network","network.","new","new,","new:","new_lib.pi","non","note:","number","number,","number.","on","onc","order","ota","ota\")","ota.connect()","ota.update()","otaa","out","over","overview","pars","path","perform","point","port","possibl","potenti","power","previou","previous","previous_version:","print(\"perform","print('not","procedur","properli","provid","provis","pycom","pycom.heartbeat(false)","pycom.rgbled(0xff00)","python","python3.","rate","reason","receiv","regardless","region=lora.eu868)","regular","relat","request","requir","reus","roll","run","running,","s","s.recv(64)","s.send(bytes([0x04,","s.setblocking(false)","s.setblocking(true)","s.setsockopt(socket.sol_lora,","same","save","scheme","script","scripts.","sd","see","send","sent","serv","server","server_ip","server_ip,","set","setup","sever","sha1","shown","simpli","size","sleep","sleep(5)","smart","socket","socket.so_dr,","socket.sock_raw)","socket.socket(socket.af_lora,","some_asset.txt","sort","sourc","special","split","start","still","structure:","such","suggests).","system","test","there'","things:","this.","this_script.pi","though","thousand","time","time.sleep(2.5)","timeout=0)","top","transport","travel","trigger","true:","turn","tutori","two","two.","ubinascii","ubinascii.unhexlify('70b3d57ed0008cd6')","ubinascii.unhexlify('b57f36d88691cec5ee8659320169a61c')","unfeas","unfortun","until","up","updat","update,","update.","update:","upload","url","url'","url,","us","user","using.","usual","variable).","vehicl","vehicle.","veri","version","version.","version:","via","w","w.deinit()","wait","want","web","well","wifi","wifi_pw,","wifi_ssid,","wifiota","wifiota(wifi_ssid,","window","wish","without","wlan","wlan()","work","{","|","}","},"],"tutorials/all/rmt.html":["#","(1,0,1)","(1,0,1,1,0,1)","(1,0,1,1,1,0,1,0,1)","(100,","(400,200,100,300,200,400)","(8000,11000,8000,11000,6000,13000,6000,3000,8000)","(note:","(remot","(unlik","*","/","0","1","10","100","1000","1000*100n","1000*channel","10000","1000n","1000u","100hz,","100n","100u","102.4","10h","10m","2","2,","20","20*100n","2u","3","3.2768","3125n","32.768","4","4,","5","500u","6","7","70,","80","80%","=","`start_level`","abov","absolut","accordingly.","allow","along","alway","avail","base","be,","between","binari","bit","bit.","board","carrier","chang","channel","channels,","class","combin","configur","continu","control","control)","creat","data","data)","data,","defin","design","desir","detail","doesn't","don't","due","durat","duration[i]","duty,","each","esp32","exampl","example,","filter","first","first,","follow","forms.","found","frequency,","function","gener","given","gpio","gpio=\"p21\",","high","high,","hour","idle,","idle.","ignored.","import","in.","inform","infrar","inputs).","interpret","key","last","led","length","list","longer","longest","low","machin","machine.rmt(channel=2)","machine.rmt(channel=2,","map","maximum","mean","modul","modulation.","more","ms","nano","number","object","occur,","occurs.","opposit","out","output","p13","p18","p21","p21,","pattern","peripher","pin","place","primarili","produc","puls","pulse.","pulses,","pycom.pulses_get()","receiv","receiving,","remot","resolut","resolution,","resolution:","rmt","rmt(channel=4,","rmt.","rmt.high))","rmt.init()","rmt.init(gpio=\"p21\",","rmt.pulses_get()","rmt.pulses_get(pulses=100)","rmt.pulses_get(timeout=500)","rmt.pulses_send(duration,","rx_filter_threshold=20)","rx_idle_threshold","rx_idle_threshold=1000)","rx_idle_threshold=1000,","seconds,","send","set","shape","shorter","shown","signal","signal.","signals,","start","start_level=rmt.high)","state","state.","style","third","this.","timeout","toggl","transmiss","transmit","tupl","tuple,","two","tx_carrier","tx_idle_level","tx_idle_level=rmt.low)","tx_idle_level=rmt.low,","type","undefin","unit","until","us","us)","valid","valu","variou","wait","want","wave","well","width","without"],"tutorials/lora/":["\"special\"","(which","2","abp","access","ad","address","advanc","application.","basic","befor","benefit","both","build","call","case","channel","class","commun","connect","crc","custom","de","demonstr","device.","differ","direct","directli","encryption.","exampl","featur","follow","forwarder.","frame","frequenc","full","function","headers,","higher","implement","includ","inform","level","long","lopi","lopy.","lora","lora)","lorawan","mac","methods,","mode","mode.","modes;","modul","modulation.","new","otaa","packet","pass","plan","protocol","radio","rang","raw","receiv","remov","select","sent","stack","support","tail","those","tutori","typic","us","well","without","work","zealand."],"tutorials/lora/lora-mac.html":["#","&","'hello'","(raw","0x0f)","2","=","ad","address","amount","asia","australia","basic","be","below","below,","both","bypass","chanc","code","connect","creat","data","data.","delay","device:","directly.","encrypt","europ","exampl","example,","factor","format","frame.","frequency,","given,","import","inform","initialis","layer","loop","lopi","lopys.","lopy'","lora","lora(mode=lora.lora,","lora)","lora.as923","lora.au915","lora.eu868","lora.us915","lorawan","mac","machin","match","minimis","mode","modul","more","need","network","param","pick","pleas","power","print(data)","radio","random","raw","receiv","received...","region","region=lora.eu868)","run","s","s.recv(64)","s.send('hello')","s.setblocking(false)","s.setblocking(true)","same","see","send","sent","sides.","socket","socket.sock_raw)","socket.socket(socket.af_lora,","spread","state","time","time.","time.sleep(machine.rng()","transmit","true:","two","tx","unit","us","wait","way,","word"],"tutorials/lora/lorawan-otaa.html":["#","(becaus","(if","(over","(wait","0x02,","0x03]))","2","5)","=","accept","activation)","air","alway","any...)","app_eui","app_key","app_key),","appeui","appkey","arrive.","asia","attempt","australia","auth=(app_eui,","authent","authentication.","back,","befor","below","block","correct","creat","data","device:","europ","exampl","expire)","false.","forever...)","frame.","gateway","gateway.","get","has_joined()","import","incorrect","initialis","join","joined...')","keep","key","lopi","lora","lora(mode=lora.lorawan,","lora.as923","lora.au915","lora.eu868","lora.has_joined():","lora.join(activation=lora.otaa,","lora.us915","lorawan","make","match","messag","method","mind","mode.","modul","network","never","non","order","otaa","over","packet","paramet","pick","pleas","point","prevent","print('not","print(data)","provided.","rate","receiv","receive,","region","region=lora.eu868)","repli","request","respons","return","s","s.recv(64)","s.send(bytes([0x01,","s.setblocking(false)","s.setblocking(true)","s.setsockopt(socket.sol_lora,","send","sent","set","socket","socket.so_dr,","socket.sock_raw)","socket.socket(socket.af_lora,","stand","state","stuck","there'","therefor","time","time.sleep(2.5)","timeout=0)","to/from","ubinascii","ubinascii.unhexlify('11b0282a189b75b0b4d2d8c7fa38548b')","ubinascii.unhexlify('ada4dae3ac12676b')","unit","until","us","wait","window"],"tutorials/lora/lorawan-abp.html":["#","'handshake'","(activ","(becaus","(if","(such","(wait","0x02,","0x03]))","2","5)","=","abp","any...)","app_swkey","app_swkey))","arrive.","asia","attempt","australia","auth=(dev_addr,","authent","back,","befor","below","block","configur","creat","data","dev_addr","devic","device:","dure","encrypt","europ","exampl","exchang","expire)","forever...)","frame","frame.","gateway","get","import","initialis","join","keep","key","lora","lora(mode=lora.lorawan,","lora.as923","lora.au915","lora.eu868","lora.join(activation=lora.abp,","lora.us915","lorawan","make","manual","match","mean","mind","mode.","need","network","never","non","nwk_swkey","nwk_swkey,","on","order","otaa","packet","param","perform","personalisation.","personalization)","pick","pleas","prevent","print(data)","procedur","procedure).","rate","receiv","receive,","region","region=lora.eu868)","s","s.recv(64)","s.send(bytes([0x01,","s.setblocking(false)","s.setblocking(true)","s.setsockopt(socket.sol_lora,","send","sent","set","socket","socket.so_dr,","socket.sock_raw)","socket.socket(socket.af_lora,","stand","start","state","struct","struct.unpack(\">l\",","stuck","there'","therefor","ubinascii","ubinascii.unhexlify('00000005'))[0]","ubinascii.unhexlify('2b7e151628aed2a6abf7158809cf4f3c')","unit","us","wait","window","without"],"tutorials/lora/lora-mac-nano-gateway.html":["\"!bb%ds\"","\"bb%ds\"","\"bbb\"","\"devic","#","%","%d","%ds:","%s'","(200)","(ack","(device_id","(device_id,","(for","(len(recv_ack)","(len(recv_pkg)","(nodes)","(true):","0):","0x01","1","1,","115200)","2","2):","200)","200):","=","==",">","_lora_pkg_ack_format","_lora_pkg_format","ack","ack_pkg","act","adapt","allow","alway","appear","applic","arriv","asia","australia","avoid","b:","basic","between","bh%ds.","bitwis","boot.pi","byte","chang","code","code,","connect","contain","demo","demo,","develop","devic","device:","device_id","device_id):","device_id,","deviceid,","differ","discuss","else:","error","europ","exampl","failed\")","fals","format","format)","forum","gateway","gateway.","h","header,","here\"","identifi","import","increas","infinit","inform","introduc","invalid","keep","len(msg),","listen","loop","lopi","lora","lora(mode=lora.lora,","lora.as923","lora.au915","lora.eu868","lora.us915","lora_sock","lora_sock.recv(256)","lora_sock.recv(512)","lora_sock.send(ack_pkg)","lora_sock.send(pkg)","lora_sock.setblocking(false)","mac","machine.uart(0,","manipul","mark","match","max","max_time_wait","messag","method","more","msg","msg)","msg))","nano","needs:","network","network.","node","note:","ok","open","os","os.dupterm(uart)","packag","package,","package.","pick","pkg","pkg:","pkg_len,","pleas","port","post.","print","print(\"ack\")","print(\"messag","print('device:","put","raw","recv_ack","recv_ack)","recv_pkg","recv_pkg)","recv_pkg[1]","recv_pkg_len","recv_pkg_len,","reduc","region","region=lora.eu868)","resend","respons","response.","rx_iq","rx_iq=true,","see","send","serial","set","simpl","singl","size","size,","socket","socket,","socket.sock_raw)","socket.socket(socket.af_lora,","someth","specif","state","string","string)","struct","struct.pack(_lora_pkg_ack_format,","struct.pack(_lora_pkg_format","struct.unpack(_lora_pkg_ack_format,","struct.unpack(_lora_pkg_format","time","time.sleep(5)","true","two","tx_iq","tx_iq=true,","uart","unit","us","user","wait","waiting_ack","while(true):","while(waiting_ack):","within"],"tutorials/lora/module-module.html":["#","(nodes)","=","==","asia","australia","b","b'ping':","capabl","connect","device:","europ","exampl","import","lopi","lora","lora(mode=lora.lora,","lora.","lora.as923","lora.au915","lora.eu868","lora.us915","match","modul","network","node","pick","pleas","pycod","raw","region","region=lora.eu868)","s","s.recv(64)","s.send('ping')","s.send('pong')","s.setblocking(false)","show","socket","socket.sock_raw)","socket.socket(socket.af_lora,","state","time","time.sleep(5)","true:","two","unit","us","via"],"tutorials/lora/rn2483-to-lopy.html":["\"forever\".","#","#(should","12","125","250","4/5","48656c6c6f","8","868000000","868000000,","=","bandwidth=lora.bw_125khz,","between","bw","coding_rate=lora.coding_4_5,","cr","data","exampl","freq","frequency=","import","keep","listen","lopi","lora","lora(mode=lora.lora,","lora.","mac","microchip","mod","network","paus","power_mode=lora.always_on,","preamble=8,","prlen","public=false)","radio","raw","rn2483","rx_iq=false,","s","s.recv(64)","send","set","sf","sf7","sf=7,","show","socket","socket.sock_raw)","socket.socket(socket.af_lora,","sync","transmit","tx","tx:","tx_iq=false,","via","while(true):","‘hello')"],"tutorials/sigfox.html":["#","(e.g.","(europe)","(see","10,","11,","12]))","2,","3,","4,","5,","6,","7,","8,","9,","=","accepted.","affect","antenna","antenna),","backend","backend,","backend.","base","be","befor","between","block","board","both","button","byte","class","click","commun","configur","connect","connectivity,","corner.","countri","coverag","creat","damag","demonstr","devic","device,","device.","differ","disengag","downlink","drop","due","ensur","entri","exampl","expect","experienc","false)","finally,","fipi","firstli","follow","fsk","id","import","info).","inform","init","instance.","issu","larg","last","link","link.","log","lopi","lot","make","messag","mode","more","navig","need","network","network,","network.","next","now","number","number,","numbers.","occur","on","oper","out","outsid","page","pleas","prevent","proper","protocol","rcz","rcz1","rcz=sigfox.rcz1)","regist","replay","reset","right","s","s.send(bytes([1,","s.setblocking(true)","s.setsockopt(socket.sol_sigfox,","see","send","sending/receiv","sent","sequenc","sigfox","sigfox(mode=sigfox.sigfox,","sigfox.","sipy,","sipy.","socket","socket.so_rx,","socket.sock_raw)","socket.socket(socket.af_sigfox,","specifi","start","start,","support","sure","sync.","trash","tutori","type","type:","uplink","upon","upper","us","variou","via","well","without","zone","​"],"tutorials/lte/":["2g/3g/lte","are.","avail","both","carrier","cat","cell","cellular","check","connect","demonstr","enabl","exampl","follow","full","function","iot","iot,","local","long","lower","lte","m1","modul","modules.","nb","new","phones,","power,","protocols.","pycom","range,","requir","same","support","sure","them.","time","tutori","us","version","wide","writing,"],"tutorials/lte/cat-m1.html":["#","(data","/","1])","443)[0][","=","access","ad","adapt","address","after.","allow","appli","attach","aw","base","be","befor","best","board","case","cat","cellular","code","compatibility.","complet","connect","connection.","consumpt","consumption.","current","data","de","deepsleep","deepsleep.","disconnect","due","ensur","errat","event","exampl","examples.","expans","fipi","firmwar","first","found","full","function","give","go","google'","here.","higher","http/1.0\\r\\n\\r\\n\")","import","important:","includ","independ","initialis","initialised,","instance).","instanti","instruct","ip","jumper","keep","latest","lead","lte","lte()","lte.attach()","lte.connect()","lte.dettach()","lte.disconnect()","lte.isattached():","lte.isconnected():","m1","mean","minimum","modem","modem.","mqtt","network","object","obtain","onc","oper","order","out","over","pin","place","pleas","power","print(s.recv(4096))","radio","radio.","receiv","remov","requir","rout","rts/ct","s","s.close()","s.connect(socket.getaddrinfo('www.google.com',","s.send(b\"get","secur","sequan","server","servic","session","setup","simpli","sm","socket","socket.socket()","special","ssl","ssl.wrap_socket(s)","ssl:","start","station","step","system","taken","those","through","time","time.sleep(0.25)","together,","us","web","wlan"],"tutorials/lte/nb-iot.html":["#","(data","1\"')","=","allow","band","band=20\"')","be","befor","board","case","cat","class","consumpt","consumption.","current","de","deepsleep","deepsleep.","differ","due","ensur","errat","event","exampl","expans","fipi","firmwar","flash","found","go","here.","higher","import","important:","independ","initialis","initialised,","instance).","instruct","iot","jumper","keep","lead","lte","lte()","lte.connect()","lte.isattached():","lte.isconnected():","lte.send_at_cmd('at!=\"addscanband","lte.send_at_cmd('at!=\"clearscanconfig\"')","lte.send_at_cmd('at!=\"disablelog","lte.send_at_cmd('at+cfun=0')","lte.send_at_cmd('at+cfun=1')","lte.send_at_cmd('at+cgdcont=1,\"ip\",\"nb.inetd.gdsp\"')","m1,","minimum","modem.","modul","narrow","nb","need","network","now","onc","oper","order","out","pass","pin","place","power","pycom","radio","radio.","receiv","remov","requir","rts/ct","sequan","shipped,","sm","socket","special","support","system","taken","those","together,","us","usag","usual...","vodafone:"],"tutorials/lte/imei.html":["\"354347xxxxxxxxx\"\\r\\n\\r\\nok.","(sysname='gpy',","02","1.17.0.b1","2018","27',","849","=",">>>","\\r\\n+cgsn:","between","cellular","check","code","compat","d0dc708","devic","doubl","enabl","esp32')","firmwar","firmware,","firstli","follow","higher.","imei","imei.","import","interact","lte","lte()","lte.send_at_cmd('at+cgsn=1')","machine='gpi","make","modul","need","network","nodename='gpy',","number:","onc","order","os","os.uname()","pycom","quot","release='1.17.0.b1',","repl.","retriev","return","run","string","sure","valu","version","version='v1.8.6","via","you'll"],"tutorials/lte/firmware.html":["\"copyright\",","\"credits\"","\"help\",","\"license\"","\"recovery\"","\"stall\"","#","$","'/path/to/catm1","'/path/to/updater.elf')","'/sd')","'/sd/updater.elf')","(clang","(default,","(do","(e.g.","(i.e","(or","(we","/flash","08","09:51:46","1,","1.0.99","1.1,0,0","10%","100%","12341","13604","14:23:58)","20","2018","2018,","2048","25","3,","3.6.5","300k","306076","37781.dup","37781.dup',","37781.dup)","37781.zip","38638.dup","38638.dup')","38638.dup',","38638.zip","4.2.1","5","5.0.0.0d","5.1.1.0","54854","5996938","7","8192","9.1.0","902.0.39.1)]","99%.",":","=","==============",">>",">>>","[########################################]","[33080]","[38638]","[gcc","absolut","again","again.","alreadi","appl","apr","archive,","around","articl","ask","attempt","auto","automat","avail","be","befor","below.","board","bootloader0","bootloader1","bootloader1*","bootloader2","bootloader2*","bootrom","break","built","button","byte","bytes:","can't","card","card,","carefulli","case","cat","catm1","chang","check","close","code","come","command","command.","command:","commands.","commun","compar","compat","completed!","completed.","compon","comput","computer.","computer:","consol","contain","content","copi","copied/upload","current","darwin","days),","describ","desir","develop","devic","differ","directli","directori","disconnect","display","distributor","do","don't","done,","download","dup","dure","each","end","enough.","ensur","even","exampl","execut","exist","fact","fail","fail,","failur","fat","file","file,","file.","file:","files,","find","finish","fipy,","firmwar","first","first,","fit","flash","follow","format","ftp.","full","g01","go","gpy,","hang","hard","here'","here:","hold","however,","https://github.com/pycom/pycom","https://software.pycom.io/downloads/sequans2.html","images,","import","important:","importantly,","increas","indic","info","information.","insid","instal","instruct","integr","interfac","interrupt","iot","iot.","it'","it.","latest","libraries/tree/master/lib/sqnsupgrad","list","llvm","load","longer","look","lte","m1","machin","make","max","mbr","messag","method","method,","method:","minut","minutes,","mirror","mode","mode.","mode...","modem","modem,","modul","module'","module):","module,","module.","module:","more","mount","nb","nb1","necessari","necessary.","need","negotiation...","new","normal","note","now","nv","old","on","on_the_fli","onc","onto","opened:","options:","origin","os","os.listdir('/sd')","os.mkfs(sd)","os.mount(sd,","otherwis","otherwise,","output","over","packag","partition,","past","path","pc.","pleas","port.","power!!!)","power!!!)................","power!!!)............................................................................","power),","preced","prepar","press","previou","primari","process","prompt","publish","pybyt","pycom","pyseri","python","python3","read","reconnect","recoveri","relat","releas","repeat","requir","reset","respond","resum","retri","return","risk","robot","run","same","save","script","scripts:","sd","sd()","seem","select","send","serial","session","sever","signific","similar","singl","size","slightli","soft","softwar","specifi","specified,","specified.","speed","sqnsupgrad","sqnsupgrade.run('/sd/catm1","sqnsupgrade.run('/sd/nb1","sqnsupgrade.run('serial_port',","sqnsupgrade.uart()","sqnsupgrade.uart(true)","sqnsupgrade.uart(true,'/flash/updater.elf')","stabl","standard","start","step","steps:","store","stp","studio","success","successfulli","successfully,","summari","sure","switch","system","take","task","termin","terminal/atom","terminal:","this:","through","time,","tool","transfer","tutorial.","two","type","uart","ue","unless","unpack","up","updat","updater.elf","upgrad","upgrade.","upload","uploaded.","us","user","v1.18.1.r1","version","version.","version:","versions.","via","visual","wait","wakeup","wakeup...","window","without","zip","zsp0","zsp1"],"tutorials/pytrack.html":["#","#f.write(\"{}","'/sd')","'\\n')","'w')","(true):","=","accelerometer.","altern","both","coord","est","exampl","f","find","gc","gc.enable()","gc.mem_free()))","github","import","l76","l76.coordinates()","l76gnss","l76gnss(py,","librari","machin","machine.rtc()","math","micropygp","modul","network","ntp","open('/sd/gp","os","os.mount(sd,","pleas","print(\"{}","print('\\nrtc","print('adjust","py","pycom/pycom","pysens","pytrack","pytrack()","record.txt',","repository.","rtc","rtc.now())","rtc.now()))","rtc.now(),","rtc.ntp_sync(\"pool.ntp.org\")","same","sd","sd()","see","set","setup","time","time.sleep(2)","timeout=30)","timezone',","us","utc","utc:',","utim","utime.localtime(),","utime.sleep_ms(750)","utime.timezone(7200)","{}","{}\".format(coord,","{}\\n\".format(coord,"],"tutorials/pysense.html":["(csv)","3d.","=","acc","acc.pitch()","acc.roll()","acceleromet","avail","basic","board","comma","data","exampl","format","here","import","lis2hh12","lis2hh12()","orient","output","over","pitch","print('{},{}'.format(pitch,","process","py","pysens","pytrack","pytrack()","read","roll","roll))","script","separ","serial.","show","sketch","time.sleep_ms(100)","true:","valu","visualis","want"],"tutorials/pyscan.html":["#","(check_uid(list(uid),","(nfc,","(rgb_bright","0))","0):","0:","0x8","0x95,","0xdd,","0xf8],","0xf9]]","=",">","[0x43,","[[0x43,","_thread","_thread.start_new_thread(discovery_loop,","access","authent","basic","card","defin","detect","else:","exampl","execution...","find","github","import","librari","list.","main","mfrc630","mfrc630(py)","nfc","nfc.mfrc630_cmd_init()","nfc.mfrc630_cmd_reset()","pre","py","pycom","pycom.rgbled(rgb_blue)","pycom.rgbled(rgb_green)","pycom.rgbled(rgb_red)","pyscan","pyscan()","read","repositori","rgb_bright","rgb_red","show","start","this,","thread","time","time.sleep(.5)","uid_len))","us","valid_card"],"firmwareapi/introduction.html":["(function","(or","(via","applic","aspir","avail","availability/non","best","beyond","board.","board/embed","build","built","categori","chapter","class","claus","code).","configurable,","contain","content","describ","descript","document","documentation,","each","effort","entir","even","extend","extens","featur","feature.","filter","find","found","function","functionality,","functions/class","further","gener","given","highli","however,","implement","individu","inform","information”","intend","introduct","it,","items,","lib","librari","libraries)","libraries.","library,","make","mani","mark","micropython","micropython.","mind,","modul","module)","modules:","more","non","note","number","offici","out","particular","pertain","place","pleas","port","port.","portable.","ports,","provid","provis","python","repository.","section","specif","standard","still","subset","support","system","thu","unavail","user","user.","warn","well","“availability:”","“gener"],"firmwareapi/pycom/":["(i.e.","access","bluetooth,","devic","devices).","differ","e.g.","etc.","hardware,","i2c,","implement","includ","micropython","modul","non","pycom","slightli","specif","spi,","support","those","underli","variat","wlan,"],"firmwareapi/pycom/machine/":["#","(1","(30000","(data","(except","(fipy,","(in","(on","(so","(the","(wake_reason,","10","20000.","24","30","4","6","=","achiev","address)","address.","allow","allows.","anoth","another,","are:","argument","associ","be","befor","bit","board","board.","board/soc","board/soc.","boot.pi","boot.py.","button","button.","byte","call","capabl","capacit","case","caus","cause.","class","clock","close","combin","come","common","configur","connect","constant","consumpt","contain","continu","convert","correspond","cpu","cpu,","critic","deep","deepsleep","deepsleep.","default","devic","disabl","disable_irq","display","down","due","durat","dure","eas","element","elsewhere.","enabl","enable_irq","enable_pul","enable_pull)","enter","esp32","esp32).","event","exampl","example,","execut","executed.","exit","expect","extern","file","filenam","finished.","form","form:","frequenc","full","function","g01),","gate","gener","given","gpio","gpio_list).","gpy,","hardwar","help(machine)","hertz.","hexadecim","high","id","id).","identifi","import","includ","independ","instanc","instance).","integ","interfac","interrupt","interv","irq","keep","length","list","long","lopy'","lte","lte).","mac","machin","machine.brown_out_reset","machine.deepsleep([time_ms])","machine.deepsleep_reset,","machine.disable_irq()","machine.enable_irq([state])","machine.freq()","machine.hard_reset,","machine.idle()","machine.info()","machine.main(filename)","machine.pin_deepsleep_wakeup(pins,","machine.pin_wake,","machine.pwron_reset,","machine.pwron_wake,","machine.remaining_sleep_time()","machine.reset()","machine.reset_cause()","machine.rng()","machine.rtc_wake,","machine.soft_reset,","machine.ulp_wak","machine.unique_id()","machine.wake_reason()","machine.wakeup_all_low","machine.wakeup_all_low,","machine.wakeup_any_high","machine.wakeup_any_high.","machine.wdt_reset,","main","main.pi","make","mani","manipul","manner","mark","member","micropython","millisecond","millisecond).","milliseconds)","miscellan","mode","mode,","mode.","modul","module.","ms)","network","number.","occur","option","order","origin","otherwis","out","overflow","p10","p13","p2,","p23.","p3,","p4,","p6,","p8","pad,","parameters.","pass","period","periods.","peripher","peripherals,","pin","port","ports,","possibl","power","pressed.","previou","product","pull","push","quick","radio","random","reason","reason.","receiv","reduc","regular","relat","remain","repres","requests.","requir","reset","reset.","resistor","restor","resum","return","run","script","script,","second","section.","see","select","sens","separ","set","setup","short","similar","sleep","sleep.","sm","softwar","someth","soon","specif","stack","stack.","state.","stop","string","substr","system","taken","task","tasks,","time","time,","timer","timer.","touch","trigger","true","true,","tupl","ubinascii.hexlify()","ulp","underli","uniqu","until","up","us","usag","valu","values.","vari","variabl","variou","via","wake","wakeup","wakeup.","water","way","wifi","within","woken","word","work","zero"],"firmwareapi/pycom/machine/adc.html":["#","(in","(re)init","*",",","0","1.1v","1.1v.","11db.","12","3.3v","3.3v,","9","=","adc","adc.attn_0db,","adc.attn_11db","adc.attn_2_5db,","adc.attn_6db,","adc.channel","adc.channel(*","adc.channel(pin='p16')","adc.deinit()","adc.init(","adc.vref(vref)","adc.vref_to_pin(pin)","adcchannel","adcchannel()","adcchannel.","adcchannel.deinit()","adcchannel.init()","adcchannel.value()","adcchannel.value_to_voltage(value)","adcchannel.voltage()","analog","apin","apin()","are:","argument.","arguments,","associ","attenu","attn","attn=adc.attn_0db)","automat","avoid","between","bit","bits=12)","block.","calibr","call","channel","channel.","check","class","connect","constant","constructor","convers","convert","creat","creation.","current","damag","device.","digit","disabl","does.","enabl","exampl","example:","exce","extern","fast","function","gpio","gpio.","hardwar","highest","import","increas","info","input","instanc","intern","internal/extern","keyword","level.","machin","machine.adc()","machine.adc(id=0)","maximum","mcu","method","method.","millivolts)","modul","more","number","object","object;","otherwis","p13","p16","p20.","p21","p22,","p6","p6.","pin","pin,","pin.","pins.","point","provid","quick","radio.","rang","read","recommend","reference.","resolut","return","same","section.","select","sources.","string","support","take","up","updat","us","usag","val","valid","valu","value.","values:","voltag","way","wipy,","without","–"],"firmwareapi/pycom/machine/dac.html":["#","(a","(~","(~0.4","(~0.8","(~1.5","0","0)","0dbv","1","1.","122hz.","125hz","12dbv","18dbv","1khz","2","20khz","3","3.3v.","3vpp","50%","600","6dbv","=","amplitud","amplitude)","analog","argument,","argument.","associ","automat","between","block.","call","channel","class","constructor","creat","creation.","dac","dac.deinit()","dac.init()","dac.tone(frequency,","dac.write(0.5)","dac.write(value)","dac_ton","dac_tone.tone(1000,","dc","disabl","enabl","exampl","float","frequenc","gener","import","integ","level","load)","machin","machine.dac('p21')","machine.dac('p22')","machine.dac(pin)","method","object","object,","offset","ohm","output","p21.","p22","pin","pin.","quick","represents:","scale.","set","signal","sine","specif","specifi","step","string","tone","up","us","usag","valu","vdd/2.","voltag","voltage)","vpp)","vpp),","vpp).","wave","write"],"firmwareapi/pycom/machine/i2c.html":["#","'123')","'abc'","'abc')","'hello')","'xy')","(0).","(3","(includ","(or","(p10=sda,","(scl)","(sda)","(typic","*","*,",",","...)","0","0,","0x08","0x10","0x10,","0x42","0x42,","0x77","1","1,","16.","2","2)","2,","2.","3","3)","5","5)","8","=","act","addr","addr.","address","address.","address:","addrsiz","addrsize=8)","argument","assign","associ","attach","b'456')","bang","baudrat","baudrate=100000)","baudrate=100000,","baudrate=20000)","between","bit","bit)","bu","buf","buf)","buf,","buf.","bus,","bus.","buse","byte","byte.","bytes)","case","class","clock","commun","condit","configur","configuration.","consist","constant","construct","constructor","continu","conveni","creat","created,","data","default","devic","device.","devices.","driver.","esp32","exampl","fals","follow","function","gener","give","given","given,","hardwar","i2c","i2c(0)","i2c(0,","i2c.deinit()","i2c.init(i2c.master)","i2c.init(i2c.master,","i2c.init(mode,","i2c.mast","i2c.master)","i2c.master,","i2c.master:","i2c.readfrom(0x42,","i2c.readfrom(addr,","i2c.readfrom_into(addr,","i2c.readfrom_mem(0x42,","i2c.readfrom_mem(addr,","i2c.readfrom_mem_into(addr,","i2c.scan()","i2c.writeto(0x42,","i2c.writeto(addr,","i2c.writeto(addr=0x42,","i2c.writeto_mem(0x42,","i2c.writeto_mem(addr,","implement","import","inclus","inform","init","initialis","integ","keyword","later","length","level","line","list","low","machin","machine.i2c(bus,","master","memaddr,","memaddr.","memori","method","methods:","mode","mode.","nbyte","nbytes)","nbytes,","non","number","object","on","on.","oper","option","p10","p11=scl)","p9","parameters:","peripher","physic","pin","pins=('p10','p11'))","pins=(sda,","print","protocol","pull","quick","rate","read","read.","receiv","recipient'","registers)","respectively.","respond","respond.","return","scan","scl","scl))","sda","sda,","second","select","send","sent","set","singl","slave","slave,","softwar","specif","specifi","standard","start","stop","stop=true)","such","take","target","those","timeout","to.","transaction).","transaction:","treat","tupl","turn","two","us","usag","valid","valu","wire","wires:","won't","write","written","written."],"firmwareapi/pycom/machine/pin.html":["#","%","%s\"","(also","(arg.id()))","(fast)","(input,","(or","*",",","...)","0","1","1)","=","`p10`","`p9`","adc","addit","alt","alt)","alt=","altern","analog","anyth","appli","are:","arg","arg=none)","argument","argument,","argument.","associ","attribut","avail","basic","board.","boolean.","call","callable.","callback","callback.","chang","changes.","class","class.","clear","configur","constant","constructor","contain","control","convert","core","creat","deep","def","depend","details.","digit","disabl","domain","down","drain","ed","edge.","empti","enabl","enabled.","etc)","event","events.","exampl","example:","examples:","expans","fall","false).","fast","follow","function","function.","gener","given,","gpio","handl","handler","handler=none,","happens.","held,","here.","high","high,","hold","hold.","i/o","id","id.","import","inform","initi","initialis","input","input/output).","instanc","interrupt","interrupts,","it.","known","led","left","level","level.","logic","low","low.","machin","machine.pin(id,","make","method","mode","mode.","mode:","mode=pin.in,","mode=pin.out)","mode=pin.out,","module.","more","new","none","none,","none.","note","object","objects.","of:","on","open","option","otherwis","out","output","output,","p","p10,","p13,","p14,","p15,","p16,","p17,","p18,","p19,","p2,","p20,","p21,","p22,","p23","p3,","p4,","p6,","p8,","p9,","p_in","p_in()","p_in.callback(pin.irq_fal","p_out","p_out(true)","p_out.toggle()","p_out.value(0)","p_out.value(1)","pass","pin","pin('p10',","pin('p12',","pin('p9',","pin()","pin([value])","pin(pin.exp_board.g16,","pin(pin.module.p9,","pin,","pin.","pin.callback(trigger,","pin.exp_board","pin.exp_board.g16","pin.exp_board.g16.id()","pin.hold([hold])","pin.id()","pin.in","pin.in,","pin.init()","pin.init(mode,","pin.irq_fal","pin.irq_high_level","pin.irq_low_level","pin.irq_ris","pin.irq_rising,","pin.mode([mode])","pin.modul","pin.module.p9","pin.module.p9.id()","pin.open_drain","pin.out","pin.out,","pin.pull([pull])","pin.pull_down","pin.pull_up","pin.pull_up,","pin.toggle()","pin.value()","pin.value([value])","pin:","pin_handler(arg):","pin_handler)","ports.","possibl","power","print(\"got","product","provid","pull","pull,","pull.","pull=none,","pull=pin.pull_up)","purpos","push","pycom'","quick","receiv","released.","reset","reset.","resistor","resistor.","resistor:","retain","return","returns:","rise","rtc","see","select","set","shortcut","sleep","state","string","support","system","through","time","together,","toggl","trigger","trigger=pin.irq_fal","true","true,","type","until","up","us","usag","valu","value,","value:","watchdog","|"],"firmwareapi/pycom/machine/pwm.html":["#","(thi","*",",","0","0,","1","1.","3.","30%","50%","5khz","7.","78","=","argument,","argument.","between","chang","channel","channel.","class","connect","constructor","creat","cycl","cycle.","duti","duty_cycl","duty_cycle=0.5)","exampl","float","frequenc","frequency)","frequency.","frequency=5000)","futur","hz","id","import","initi","instanc","integ","keyword","khz","machin","machine.pwm(timer,","method","modul","object.","oscil","p12","pin","pin,","pin='p12',","puls","pwm","pwm(0,","pwm.channel(0,","pwm.channel(id,","pwm_c","pwm_c.duty_cycle(0.3)","pwmchannel","pwmchannel.","pwmchannel.duty_cycle(value)","quick","return","set","specifi","string","timer","up","upgrades).","us","usag","valu","width","–","—"],"firmwareapi/pycom/machine/rtc.html":["#","(sntp).","(tz","(year,","*",",","...)","0)","0))","0,","0.","1,","10,","10:30am","13,","15","2,","2017","28,","2nd","30,","4,","5,","=","accord","achiev","are:","argument","automat","between","class","clock","completed,","connected.","constant","constructor","creat","current","date","datetim","day[,","default","disabl","drive","exampl","example.","example:","fals","februari","fetch","form:","geograph","hour[,","id","ignor","import","init","initialis","initialisation.","keep","last","like:","locat","machin","machine.rtc(id=0,","method","method.","microsecond[,","minute[,","month,","more","multipl","none","ntp","ntp_sync","number","object.","option","oscil","otherwise:","paramet","pass","period","print(rtc.now())","quick","results.","return","rtc","rtc()","rtc(id=0)","rtc.","rtc.init((2014,","rtc.init((2017,","rtc.init(datetime=none,","rtc.internal_rc","rtc.internal_rc,","rtc.now()","rtc.ntp_sync(\"pool.ntp.org\")","rtc.ntp_sync(server,","rtc.synced()","rtc.xtal_32khz","second","second[,","seconds.","see","select","server","server.","set","shortest","similar","sourc","source:","source=rtc.internal_rc)","specif","time","time.","time.timezon","track","true","tupl","tuple:","tzinfo","tzinfo]]]]])","up","updat","update_period","update_period=3600)","updates.","url","us","usag"],"firmwareapi/pycom/machine/spi.html":["#","(``p10``,","(``p19``,","(it","(p10","*",",","...)","0","0.","0x02,","0x03,","0x04,","0x05]))","0x05]),","1","1,","16","2mhz","3","32.","5","8,","=","@","``p11``","``p14``)","``p20``","``p21``)","accept","addit","any).","argument","assign","at.","baudrat","baudrate=1000000,","baudrate=2000000,","bit","bit:","bits=8,","both","bu","buf","buf.","buffer","bus,","bus.","bus:","byte","bytearray(5)","class","clk,","clk,p11","clock","configur","constant","construct","constructor","contain","creat","data","default","differ","driven","each","edg","exampl","extra","first","firstbit","firstbit=spi.msb)","firstbit=spi.msb,","given","given,","i2c;","id","idl","import","init","initialis","initialisation.","initialised.","last","length.","level","line","lines:","machin","machine.spi(id,","made.","main","master","master.","master:","method","miso","miso))","miso).","miso.","mode","mode,","mode=spi.master,","model","mosi","mosi,","nbyte","non","none","number","object","option","p14","paramet","parameters,","parameters:","pass","phase","phase=0)","phase=0,","physic","pin","pins=('p19','p20','p21'))","pins=(clk,","polar","polarity=0,","protocol","quick","rate.","rbuf","rbuf)","read","read.","read_buf)","read_buf.","receiv","requir","respectively.","return","same","sampl","sck","sck,","second","see","select","send","serial","set","signific","similar.","sit","specifi","spi","spi(0,","spi.deinit()","spi.init(mode,","spi.lsb","spi.lsb.","spi.mast","spi.master.","spi.msb","spi.read(5)","spi.read(nbytes,","spi.readinto(buf,","spi.write(buf)","spi.write(bytes([0x01,","spi.write_readinto(bytes([0x01,","spi.write_readinto(write_buf,","transfer,","tupl","turn","us","usag","valu","veri","width","write","write.","write=0x00)","write_buf","written","written."],"firmwareapi/pycom/machine/uart.html":["#","'p21',","'p22',","'p23'))","(0)","(``p20``","(``p20``,","(``p3``","(along","(in","(not","(p0)","(p1)","(txd/rxd","*",",","...)","0,","1","1,","1.5","10","13","2","2.","3","4","5","5,","6,","7","7,","8","8.","9600)","=","``p21``)","``p21``,","``p22``and","``p23``)","``p4``)","act","anyth","appli","assign","avail","available.","base","baudrat","baudrate.","baudrate=9600)","baudrate=9600,","bit","bits,","bits.","bits=8,","break","bu","buf","buf.","buffer","bus.","byte","bytes.","cellular","charact","character)","character.","characters,","characters.","check","class","clock","commun","complete.","condit","configur","confus","consist","constant","construct","constructor","contain","control","control)","creat","ct","cts))","cts.","data","default","defin","disabled.","done","drive","duplex","durat","elapses,","end","exampl","exists,","exists.","false.","flow","functionality.","given","given,","gpy/fipi","hardwar","here","immediate.","implement","import","in.","indic","init","initialis","irq","it,","item","last","len(buf)","level","limit","line","line,","lines:","list","low","machin","machine.uart(bus,","made","made.","mani","method","methods:","much","multipli","nbyte","nbytes])","newlin","non","none","none):","none,","none.","number","object","on","only)","oper","order).","otherwis","otherwise,","paramet","parameters:","pariti","parity,","parity=none,","per","physic","pin","pins.","pins=('p20',","pins=('p20','p21'))","pins=(txd,","pins=none,","possible.","protocol.","quick","radio.","rate.","read","read,","reading.","regardless","return","rt","rts,","rx","rxd","rxd,","same","select","send","sent","serial","set","sources:","specifi","standard","stop","stop=1)","stop=1,","store","stream","string","such","take","taken,","therefor","time","timeout","timeout.","timeout_char","timeout_chars=2,","timeout_m","transact","transmit","trigger","true","turn","tx","txd","txd,","txd.","type","uart","uart(1,","uart.any()","uart.deinit()","uart.even","uart.even,","uart.init(9600,","uart.init(baudrate=9600,","uart.odd","uart.odd.","uart.read(10)","uart.read(5)","uart.read([nbytes])","uart.readall()","uart.readinto(buf)","uart.readinto(buf[,","uart.readline()","uart.rx_ani","uart.sendbreak()","uart.wait_tx_done(timeout_ms)","uart.write('abc')","uart.write('hello')","uart.write(buf)","uart/usart","uart2","uart_1","unavail","unit","up","us","usag","use:","using:","valu","value:","wait","well.","whether","wide.","write","written"],"firmwareapi/pycom/machine/wdt.html":["\"feed\"","#","0.","2","=","applic","call","class","configur","constructor","correctly.","crash","creat","enabl","enabling,","end","ensur","everyth","exampl","expir","fed","feed","function","given","id","import","init","initialis","initialisation.","it.","machin","machine.wdt(id=0,","method","milliseconds.","non","object","onc","paramet","period","place","point","prevent","quick","re","recover","reset","restart","run","second","see","sensibl","start","state.","stop","system","system.","time.","timeout","timeout)","timer.","up","us","usag","verifi","watchdog","wdt","wdt(timeout=2000)","wdt.feed()","wdt.init(timeout)"],"firmwareapi/pycom/machine/timer.html":["#","%","%f","(float),","(for","(integer)","(integer).","(total","*","+=",",","0","0.","1","1,","1.25","10","10,000u","100u","100us.","10:","=","==","__init__(self):","_seconds_handler(self,","alarm","alarm):","alarm.","alarm.callback(handler,","alarm.cancel()","alarm:","arg","arg:","arg=none)","arg=none,","argument","be","bigger","call","callback","chrono","chrono.read()","chrono.read_ms()","chrono.read_us()","chrono.reset()","chrono.start()","chrono.stop()","chrono:","chronomet","chronometer.","class","class.","clock","clock()","clock:","close","compens","concept","condit","constructor","count","creat","creation.","def","delay","differ","disabl","disabled.","elaps","elapsed.","element","enforced).","exactitud","example,","example:","finish","first","function","function.","gil","given","great","group","guarante","handl","handler","handler:","import","inform","intern","interrupt","interrupts,","interv","interval.","lap","lap\"","lap)","lap))","last","longer","machin","mani","measur","method","microsecond","microseconds,","microseconds.","milisecond","milliseconds.","more","ms,","needed.","none","none,","notes.","notifi","number","object","object.","on","option","overhead,","paramet","pass","passed\"","periodic:","periodic=false)","periodic=true)","posit","print(\"","print(\"%02d","print(\"\\nth","print()","product","pycom'","race\"","racer","read","realli","receiv","releas","repeatedli","reset","run,","s,","same","second","seconds.","see","self.__alarm","self.second","self.seconds)","set","simul","span","spans.","specif","specifi","specified,","specified.","speed,","start","stop","subclasses:","tasks,","that.","thread","time","time.sleep(1.25)","time.sleep(1.5)","timer","timer.alarm(handler=none,","timer.alarm(self._seconds_handler,","timer.chrono()","timer.sleep_us()","took","total","total)","trigger","true.","two","us","us,","us:","varieti","without","–"],"firmwareapi/pycom/machine/sd.html":["#","'/sd')","'r')","'w')","(no","...)","/sd","1","32","=","addit","allow","automat","bit","boards,","card","card,","card.","check","class","cmd","combin","compat","configur","connect","constructor","content","creat","current","dat0,","disabl","enabl","exampl","expans","extern","f","f.close()","f.readall()","f.write('test","fat16","fat16/32","fat32.","file","firmwar","follows:","format","futur","gb.","implement","import","increas","initialisation.","insert","librari","machin","machine.sd(id,","make","memori","method","micro","mode.","modul","mount","needed)","note","object.","on","open('/sd/test.txt',","oper","operations')","os","os.listdir('/sd')","os.mount(sd,","p23:","p4:","p8:","paramet","part","pin","pleas","pull","pycom","quick","resistor","run","sclk","script.","sd","sd()","sd.deinit()","sd.init()","sd.init(id=0)","see","simpli","singl","sizes.","socket","standard","support","sure","system.","tri","up","updat","us","usage:","work","write"],"firmwareapi/pycom/machine/can.html":["#","'p23'))","(0x020,","(0x040,","(0x200,","(>=","(can","(extended).","(filter,","(id,","(id=0x012,","(if","(in","(rtr=true).","(standard)","*","*,",",","...)","0","0.","0.2).","0x001","0x010),","0x010,","0x02,","0x020","0x03,","0x030","0x030),","0x04,","0x040","0x05,","0x050)])","0x050.","0x05]),","0x06,","0x07,","0x08]))","0x100,","0x200,","0x300","0x300,","0x400","0x400])","0x7fc)])","0x7ff),","1","1000000.","11bit","128),","2,","2.0","29bit","3","3,","32","4,","5","5,","6,","7,","8","8]))","=",">>>","[(0x001,","[(0x100,","[0x100,","accept","accepted.","ad","allow","alway","any)","applied.","are:","arg","arg=none)","argument","argument.","automatically,","available,","available.","base","baudrat","baudrate=500000,","be","between","bit","bu","built","bus,","bus.","byte","bytes.","call","callback","callback.","can(0,","can(mode=can.normal,","can.callback(handler=can_cb,","can.callback(trigger,","can.deinit()","can.events()","can.filter_list","can.filter_list,","can.filter_mask","can.filter_rang","can.filter_range,","can.format_both,","can.format_both.","can.format_ext,","can.format_std","can.format_std,","can.init(mode=can.normal,","can.norm","can.normal,","can.recv()","can.recv(timeout=0)","can.rx_fifo_not_empti","can.rx_fifo_not_empty,","can.rx_fifo_overrun","can.rx_fifo_overrun,","can.rx_fram","can.rx_frame,","can.send(id,","can.send(id=0x0020,","can.send(id=0x010,","can.send(id=0x012,","can.send(id=12,","can.silent,","can.silent.","can.soft_filter(can.filter_list,","can.soft_filter(can.filter_mask,","can.soft_filter(can.filter_range,","can.soft_filter(mode,","can.soft_filter(none)","can_cb(can_o):","can_o.recv())","class","classic","clear","constant","constructor","contain","control","controller,","controller.","creat","data","data,","data=b'123',","data=bytes([0x01,","data=bytes([1,","data=none,","def","defin","devic","disabl","drop","due","e.g.","ed","elements.","empti","esp32","event","exampl","example:","extend","extended)","extended=false)","extended=true)","externally.","extnt","fals","fifo","fifo.","fill","filter","filter_list","filter_list)","filtering.","filters,","float","follow","form:","format","frame","frame_format","frame_format=can.format_std,","frames,","full","full.","function","handler","handler=none,","happens.","high","id","id=0x12","identifi","immedi","import","indic","init","initi","initialisation.:","instanc","intern","interrupt","it.","larg","left","length.","like:","list","machin","machine.can(bus=0,","mask","mask).","match","mean","messag","message.","messages,","method","method.","mode","mode=can.normal,","modes:","more","name","need","new","non","none","none,","normal.","note","number","object","object.","occur","on","option","order","order).","otherwis","overhead","paramet","pass","peripher","pin","pins=('p22',","pleas","point","possibl","present,","present:","print('can","queu","queue","queue,","queue.","quick","rang","receiv","received.","receiver.","recommend","registri","relev","remain","remot","request","request.","return","rtr","rtr,","rtr=false,","rtr=true)","rx","rx:',","rx_queue_len","rx_queue_len=128,","s","second","see","select","selected,","send","sent","set","silent","sn65hvd230.","snif","soft","softwar","special","specif","specifi","speed.","standard","support","take","tale","test.","therefor","this:","time","timeout","together,","traffic","transceiv","trigger","trigger=can.rx_fram","trigger=can.rx_frame)","tupl","tx","tx,","type","up","us","usag","valu","versa.","vice","well","whenev","width","won't","|"],"firmwareapi/pycom/machine/rmt.html":["\"idle\"","#","(1,0,1,0,1,0,1,0,1)","(high/low)","(level,","(remot","(resolution)","0","0%","1","1.","100%.","10000","1000n","100n","102.4","128","2","3","3.2768","31.","3125n","32.768","4","5","6","65535.","7","7.","=","abov","accept","addit","again","anoth","anyth","argument","be","below","between","bit","bit/pulse,","bits,","board","both","call","carrier","carrier'","carrier_duty_perc","carrier_freq_hz","carrier_level","case","channel","channel,","channel.","channel:","class","compos","configur","configuration.","constant","construct","constructor","contain","control","control)","creat","data","data)","data,","data.","defin","defined,","deinit()","deinitialis","depend","design","desir","dictat","drop","due","durat","duration):","duration,","duration.","duti","each","elements,","elements.","equal","evalu","exactli","example:","exceeded.","extra","finished,","first","follow","frequenc","frequency,","function","gener","given","given,","given.","gpio","gpio=\"p20\",","hz.","ignor","import","incom","indefinitely.","infrar","init","init()","initialis","initialisation.","initialised.","item","keep","kept","key","last","led","length","less","level","limit","longer","machin","machine.rmt(channel,...)","machine.rmt(channel=3)","machine.rmt(channel=3,","mandatori","match","maximum","mention","method","microseconds.","mind","minimum","mode","modul","modulate,","more","ms","need","number","number,","object","object.","occur","on","only.","optional.","output","paramet","parameter.","parameters,","parameters.","parameters:","percent","peripher","pin","pin.","primarili","provid","provided,","puls","pulse,","pulse.","pulse:","pulses,","pulses.","pulses_get","pycom.pulses_get()","quick","read","receiv","reception.","reconfigur","remot","repres","resolut","rest","return","rmt","rmt.deinit()","rmt.high","rmt.init(gpio,","rmt.init(gpio=\"p20\",","rmt.low,","rmt.low.","rmt.pulses_get(pulses,","rmt.pulses_send(duration,","rmt.recv_pulses()","rmt.send_pulses(duration,","row","rtm","rx","rx/tx","rx_filter_threshold","rx_filter_threshold,","rx_idle_threshold","rx_idle_threshold,","rx_idle_threshold.","rx_idle_threshold=12000)","same","see","select","send","send.","sent","sent,","sent/receiv","sequenc","seri","set","shorter","signal","signal'","signal,","signal.","signals.","singl","specifi","specified,","start_level","start_level)","state","structure:","time","timeout","timeout)","toggl","transmiss","tupl","tuples,","tx","tx/rx,","tx_carrier","tx_carrier)","tx_idle_level","tx_idle_level,","tx_idle_level=0)","type","unit","until","us","usag","use.","valid","valu","value.","value:","variou","wait","width","within","without"],"firmwareapi/pycom/network/":["access","avail","configur","configuration.","driver","hardwar","interfaces.","modul","network","provid","rout","specif","us","within"],"firmwareapi/pycom/network/wlan.html":["\"tradit","#","'192.168.0.1'))","'192.168.0.1',","'255.255.255.0',","'8.8.8.8'))","'my_network_key'))","'your","(but","(e.g.","(extern","(ip,","(onli","(p12)","(sec,","(sec,).","(ssid,","(the","*",",","...)","0,","1","11.","1:","2048","3","4","6","=","abc1de45bf).","access","address","address.","alreadi","alway","antenna","antenna,","antenna.","antenna=none,","antenna=wlan.int_ant)","ap","ap)","ap.","applic","are:","argument","auth","auth=(network.wlan.wpa2,","auth=(wlan.wpa2,","auth=(wlan.wpa2,'www.wipy.io'),","auth=none,","authent","avail","besid","between","bit","board","bssid","bssid,","bssid=none,","byte","ca","ca_cert","ca_certs=none,","case","certfil","certfile=none,","certif","certificate.","certifl","channel","channel,","channel=1,","channel=7,","class","client","code","config","config=['dhcp'","configtuple])","configur","configuration.","configured.","connect","connected,","constant","constructor","creat","default","develop","dhcp","disabl","disconnect","dns)","dns_server).","do:","done","driver","element","elements:","enabl","esp32","exampl","example,","exist","extern","fals","featur","fix","format","format).","free","function","gateway,","get/set","given","given,","given.","go","handl","hexadecim","hidden","hidden=false)","id","ident","identity=none)","import","info","init","initialis","instanc","instance:","interface.","intern","internal).","ip","it.","it'","key","key'))","key).","key.","keyfil","keyfile=none,","list","long","mac","machin","mandatory.","maximum","maximum.","method","millisecond","mode","mode).","mode,","mode.","mode:","mode=pin.out)(true)","module,","module.","name","name.","need","negoti","network","network.wlan(id=0,","network.wlan(mode=network.wlan.sta)","none","none,","note","now","number","object","object,","oem","option","otherwise.","output","p12","param","paramet","parameters.","part","pass","password","password),","password.","path","perform","pin","pin('p12',","pin.","pkcs8","point","point.","power","power_sav","power_save=false,","print(wlan.ifconfig())","privat","processor","provid","quick","radio.","rang","re","repres","return","rsa","rsaprivatekey\"","rssi).","same","save","scan","sec","sec,","secur","security.","security:","see","select","sens","server.","set","setup","sever","socket","special","ssid","ssid',","ssid,","ssid.","ssid='wipi","ssid=none,","ssleay","sta","static","station","string","subnet,","subnet_mask,","subsystem","succeed.","system","thekeyfil","things.","time","time.sleep_ms(50)","timeout","timeout=none,","to.","true","true.","tupl","tuple,","tuple.","type","type:","us","usag","usage:","used,","usernam","username,","usual","valid","valu","values.","wait","wifi","wipy.","without","wlan","wlan',","wlan(mode=wlan.sta)","wlan.antenna([antenna])","wlan.ap","wlan.ap,","wlan.ap.","wlan.auth([auth])","wlan.channel([channel])","wlan.connect('your","wlan.connect(ssid,","wlan.connect(ssid='mynetwork',","wlan.deinit()","wlan.disconnect()","wlan.ext_","wlan.ext_ant.","wlan.ifconfig(config=('192.168.0.107',","wlan.ifconfig(config=('192.168.0.4',","wlan.ifconfig(id=0,","wlan.init(mode,","wlan.init(mode=wlan.ap,","wlan.init(mode=wlan.sta)","wlan.int_ant,","wlan.isconnected()","wlan.isconnected():","wlan.mac()","wlan.mode([mode])","wlan.scan()","wlan.ssid([ssid])","wlan.sta,","wlan.sta_ap","wlan.sta_ap.","wlan.wep","wlan.wep,","wlan.wpa,","wlan.wpa2","wlan.wpa2,","wlan.wpa2.","wlan.wpa2_","wlan.wpa2_ent."],"firmwareapi/pycom/network/server.html":["#","'password'),","'python'),","(and","(connect","(in",",","...)","=","accept","affect","again","behaviour","both.","chang","check","class","class'","configur","connections),","constructor","control","creat","device.","disabl","effect","enabl","exampl","example:","fals","ftp","import","init","initialisation.","instance,","login=('micro',","method","network","network.server()","network.server(id,","new","option","otherwise.","paramet","passed.","password","perform","pycom","quick","return","run","second","seconds)","see","server","server(login=('user',","server).","server.","server.deinit()","server.init(*","server.init(login=('user',","server.isrunning()","server.timeout()","server.timeout(300)","server.timeout([timeout_in_seconds])","servic","set","start","stop","telnet","timeout","timeout.","timeout=300)","timeout=60)","timeout=600)","true","us","usag","user,","whether"],"firmwareapi/pycom/network/bluetooth/":["#","%","%x'","&","'heart","(apple'","(bit","(ble)","(bt_o):","(char.properties()","(commonli","(gap)","(hint:","(in","(low","(mac,","(p12)","*",",","...)","0","0,","1)","10","16","20","31","4","6","=","==",">","accept","access","act","addr_typ","addr_type,","address","adv","adv:","adv_typ","adv_type,","advertis","advertised.","advertisement.","advertisements,","advertisements.","advertiser:","advertising.","allow","alway","amount","antenna","antenna,","antenna.","antenna=none)","are:","arg","arg=none)","argument","argument.","arguments:","ascii","avail","available.","background.","basic","below","between","bit","ble","block","bluetooth","bluetooth()","bluetooth,","bluetooth.adv_128service_data,","bluetooth.adv_128srv_cmpl,","bluetooth.adv_128srv_part,","bluetooth.adv_16srv_part,","bluetooth.adv_32service_data,","bluetooth.adv_32srv_cmpl,","bluetooth.adv_32srv_part,","bluetooth.adv_adv_int,","bluetooth.adv_appearance,","bluetooth.adv_dev_class,","bluetooth.adv_flag,","bluetooth.adv_manufacturer_data","bluetooth.adv_manufacturer_data)","bluetooth.adv_name_cmpl)","bluetooth.adv_name_cmpl))","bluetooth.adv_name_cmpl,","bluetooth.adv_name_short,","bluetooth.adv_service_data,","bluetooth.adv_t16srv_cmpl,","bluetooth.adv_tx_pwr,","bluetooth.advertise([enable])","bluetooth.advertise(true)","bluetooth.bl","bluetooth.callback(trigger=bluetooth.client_connect","bluetooth.callback(trigger=none,","bluetooth.char_notify_ev","bluetooth.char_read_event,","bluetooth.char_write_event,","bluetooth.client_connected,","bluetooth.client_connected:","bluetooth.client_disconnect","bluetooth.client_disconnected,","bluetooth.client_disconnected:","bluetooth.conn_adv,","bluetooth.conn_dir_adv,","bluetooth.connect('112233eeddff')","bluetooth.connect(mac_addr)","bluetooth.deinit()","bluetooth.disc_adv,","bluetooth.disconnect_client()","bluetooth.events()","bluetooth.ext_","bluetooth.ext_ant.","bluetooth.get_adv()","bluetooth.get_advertisements()","bluetooth.init(id=0,","bluetooth.int_ant,","bluetooth.isscanning()","bluetooth.isscanning():","bluetooth.new_adv_event,","bluetooth.non_conn_adv,","bluetooth.prop_auth,","bluetooth.prop_broadcast,","bluetooth.prop_ext_prop","bluetooth.prop_indicate,","bluetooth.prop_notify,","bluetooth.prop_read):","bluetooth.prop_read,","bluetooth.prop_write,","bluetooth.prop_write_nr,","bluetooth.public_addr,","bluetooth.public_rpa_addr,","bluetooth.random_addr,","bluetooth.random_rpa_addr","bluetooth.resolve_adv_data(adv.data,","bluetooth.resolve_adv_data(data,","bluetooth.scan_rsp","bluetooth.service('abc123')","bluetooth.service(uuid,","bluetooth.set_advertisement(*","bluetooth.set_advertisement(name=\"advert\",","bluetooth.set_advertisement(name='lopy',","bluetooth.start_scan(","bluetooth.start_scan(10)","bluetooth.start_scan(20)","bluetooth.start_scan(timeout)","bluetooth.stop_scan()","bluetoothserverservice.","board","bool","both","break","bt","bt.connect(adv.mac)","bt.get_adv()","bt.resolve_adv_data(adv.data,","bt.start_scan(","bt_o.events()","byte","bytes:","cach","call","call.","callback","callback.","case","central","char","char.read()))","characterist","chars:","class","classic","clear","client","client.","close","combined):","commun","complet","configur","configuration.","conn","conn.disconnect()","conn.services()","conn_cb","connect","connected\")","connections.","constant","constrained,","constructor","contain","contain.","control","convert","creat","current","currently,","data","data)","data.","data_typ","data_type)","def","default","design","details.","develop","devic","device\")","device,","device.","disabl","disconnected\")","driver","dure","easi","eitherbluetooth.int_ant,","elapses.","elif","else:","enabl","energi","event","events.","events:","exampl","example:","examples:","except:","execut","extern","fails.","fals","fifo","fifo.","flag","flow","follow","free","fro","function","gap","gatt","gattcconnection.","gener","get","get_adv()","given","handler","handler=conn_cb)","handler=none,","here)","hexadecim","ibeacon","ibeacons).","id","identifi","immediately,","immediately.","import","indefinit","init","initi","initialis","integ","intern","isprimari","isprimary=true,","it.","itself","it'","known","larg","last","left","ling","list","listen","long","low","mac","mac_addr","manufactur","manufacturer_data","manufacturer_data=\"lopy_v1\")","manufacturer_data=none,","maximum","messag","message.","method","method,","method.","methodolog","mfg_data","mfg_data:","mobil","mode","mode.","mode:","mode=bluetooth.ble,","mode=pin.out)(true)","module,","module.","more","name","name=none,","nbr_char","nbr_chars=1,","network","network.bluetooth(id=0,","new","none","none.","noth","number","object","object,","object.","occur","occurs.","oem","on","one.","ongo","open","option","order","otherwise.","output","p12","param","pars","part","particular","pass","payload","pc","perform","peripher","pin","pin('p12',","pin.","platforms).","power).","power,","present,","present.","primari","print(\"client","print(\"error","print('char","print('read","print(bluetooth.resolve_adv_data(adv.data,","print(ubinascii.hexlify(mfg_data))","prior","process","process.","profil","progress.","properti","provid","pycom","quick","radio","radio.","rate':","read","receiv","received.","registri","request","resolv","resolve_adv_data()","resourc","retriev","return","role","rssi","rssi,","same","scan","scanning.","second","section","see","seen","select","send","sent","server","server.","servic","service.","service.characteristics()","service.uuid())","service_data","service_data=none,","service_uuid","service_uuid=b'1234567890123456')","service_uuid=none)","services:","set","set_advertisement()","shown","sign","signal","simultan","small","space","specif","specifi","start","start=true)","stop","strength","string","structure:","subset","succe","support","take","things.","time","time.sleep(0.050)","timeout","tri","trigger","triggered.","true","true:","try:","tupl","type","type(service.uuid())","type.","type:","types,","ubinascii","ubinascii.hexlify(adv.mac)","until","us","usag","usage:","used,","used.","uuid","valu","value.","variou","won't","work","zero.","{}","{}'.format(char.uuid(),","{}'.format(service.uuid()))","|"],"firmwareapi/pycom/network/bluetooth/gatt.html":["(att),","(the","advertis","alreadi","att","attribut","between","bluetooth","broken","call","case,","characterist","characteristics.","client","come","commun","concept","connect","data","defin","definitions,","devic","devices,","disconnected.","each","energi","establish","exclusive;","gap.","gatt","gener","gone","hold","i.e.","import","it'","known","lookup","low","made.","manag","mean","on","onc","phone/tablet),","process","profil","protocol","relat","remain","rememb","request","send","server","server,","server.","servic","services,","stand","stop","store/manag","table.","through","time.","two","until","us","way"],"firmwareapi/pycom/network/bluetooth/gattcconnection.html":["#","(commonli","(server)","1)","=","addr","adv","adv:","again","alreadi","around","assum","ble","bluetooth","bluetooth()","bluetooth.connect(adv.mac)","bluetooth.get_adv()","bluetooth.start_scan(","break","class","client","close","connect","connection.","connection.disconnect()","connection.isconnected()","connection.services()","contain","continu","data","devic","example:","except:","fals","gatt","gattcconnect","gattcservic","import","initi","known","list","master","master,","method","network","none","none.","object","open","open.","otherwis","otherwise.","perform","peripher","phone/tablet/pc).","print(\"connect","print(service.uuid())","print(services)","receiv","request","respons","return","scan","search","server,","servic","services:","slave.","start","still","succeeds.","transact","true","true:","try:","ubinascii","until","{}\".format(ubinascii.hexlify(adv.mac)))"],"firmwareapi/pycom/network/bluetooth/gattccservice.html":["128","16","32","allow","bit","ble","byte","call","case","categoris","characterist","characteristics,","characteristics.","chunk","class","client","connect","contain","control","data","each","fals","follow","gattccharacterist","gattcservic","id","instanc","integer,","known","list","long","method","multipl","numer","object","object.","one.","otherwise.","over","perform","peripher","primari","request","return","servic","service.","service.characteristics()","service.instance()","service.isprimary()","service.uuid()","services.","specif","succeeds.","true","uniqu","up","us","uuid","uuid.","uuids,","valu"],"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":["(though","0.","128","16","3","32","accelerometer,","accept","allow","arg","arg=none)","argument","array","axi","bit","bluetooth.char_notify_event.","byte","callback","callback.","case","characterist","characteristic,","characteristic.","characteristic.callback(trigger=none,","characteristic.instance()","characteristic.properties()","characteristic.read()","characteristic.uuid()","characteristic.value()","characteristic.write(b'x0f')","characteristic.write(value)","class","client.","concept","constant","contain","data","data,","details.","ed","encapsul","etc.).","execut","follow","function","gatt","gattccharacterist","get","given","given,","gps,","handler","handler=none,","hasn't","id","indic","instanc","integ","integer,","latitud","local","long","longitud","manag","method","more","noth","notif","now","object","object.","own","pass","point","properti","read","regist","relat","repres","request","return","section","see","send","server","server.","service.","singl","smallest","store","such","together.","trigger","triggered.","used.","uuid","uuids,","valu","value.","without","write","written.","x/y/z","yet,"],"firmwareapi/pycom/network/bluetooth/gattsservice.html":["&","*",",","16","act","allow","alreadi","are:","argument","att","byte","call","categoris","characterist","characteristic.","characteristics,","characteristics.","chunk","class","combin","configur","control","creat","data","data,","definitions.","devic","each","ed","flags.","follow","gatt","gattscharacteristic.","gattsservic","hold","id","initi","integ","integer,","known","long","lookup","master","method","mode,","multipl","new","numer","object","object.","over","peripher","permiss","permissions,","previous","properti","properties,","properties.","request.","return","server","servic","service.","service.characteristic('temp',","service.characteristic(uuid,","service.start()","service.stop()","services.","set","slave","specif","start","started.","stop","string","take","uniqu","up","us","uuid","uuid.","valu","value)","value.","value=25)"],"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":["#","&","(bt_o):","(though","+=","0","0xf1:","1","123","3","=","accelerometer,","advertis","allow","are:","arg","arg=none)","argument","array","axi","bit","bluetooth","bluetooth()","bluetooth.advertise(true)","bluetooth.callback(trigger=bluetooth.client_connect","bluetooth.char_read_ev","bluetooth.char_write_event.","bluetooth.char_write_event:","bluetooth.client_connected:","bluetooth.client_disconnected,","bluetooth.client_disconnected:","bluetooth.service(uuid=b'1234567890123456',","bluetooth.set_advertisement(name='lopy',","bt_o.events()","byte","call","call.","callback","callback.","char1_cb_handler(chr):","char1_read_count","char2_cb","char2_read_count","characterist","characteristic,","characteristic.","characteristic.callback(trigger=none,","characteristic.events()","characteristic.value()","characteristic.value(123)","characteristic.value([value])","characteristics.","chr.events()","chr1","chr2.callback(trigger=bluetooth.char_read_event,","class","clear","concept","conn_cb","connected\")","contain","creat","data","data,","def","device:","disconnected\")","elif","else:","encapsul","etc.).","event","events.","exampl","execut","flag","follow","function","gatt","gattscharacterist","get","given,","global","gps,","handler","handler=char2_cb_handler)","handler=conn_cb)","handler=none,","identifi","implement","import","integ","integer,","isprimary=true)","last","latitud","longitud","manag","method","network","noth","object","object.","occur","occurs.","own","pass","point","print(\"client","print(\"writ","relat","request","return","section.","seen","server","servic","service_uuid=b'1234567890123456')","set","singl","smallest","srv1","srv1.characteristic(uuid=b'ab34567890123456',","string","such","take","trigger","triggered.","used.","valu","value=5)","x/y/z","{}\".format(chr.value()))","|"],"firmwareapi/pycom/network/lora.html":["#","&","(0","(0),","(1)","(1),","(2),","(2):","(3)","(4).","(a","(activ","(data,","(dev_addr,","(dev_eui,","(e.g.","(even","(if","(in","(join","(lora.lora).","(lora.lora):","(may","(onli","(or","(over","(rx_timestamp,","(so_*","*",",",",region=lora.eu868,",",timeout=none,","...)","0","0,","0.","0x02,","0x03]))","1","1..254","1.0.2","100)","12.","12:","14","15","2","2,","2.","20","254","255","3","3]))","4","5","5)","50%","7","7).","71","8","8.","863000000","868","868mhz","870000000","902000000","915","915mhz","928000000","=","abp","accept","accord","ack","activ","activation)","activation:","adapt","add","add.","addit","address","adr","adr,","adr=false,","again.","air","allow","alreadi","alway","always_on","ambl","antenna","antenna),","any)","app_eui","app_eui,","app_key","app_key)","app_key),","app_swkey","app_swkey))","app_swkey).","applic","appropri","are:","arg=none)","argument","arguments,","around","asia","attempt","australia","auth,","auth:","auth=(app_eui,","auth=(dev_addr,","auth=(dev_eui,","authent","automat","automatically,","band","band,","band.","bandwidth","bandwidth:","bandwidth=lora.bw_125khz,","batteri","be","befor","below","below:","between","binascii.unhexlify('00000005'))[0]","bind()","bit","block","but,","byte","call","callback","callback.","card.","case","centr","chang","changed.","channel","channel,","channel.","check","class","class.","class:","clear","code","coding_r","coding_rate=lora.coding_4_5,","come","command","complet","completes.","compliant","configur","configuration.","confirm","connect","constant","constructor","contain","counters,","creat","current","custom","cycl","cycle.","damag","data","data.","db","dbm).","dbm.","deepsleep","deepsleep.","def","default","defin","demonstr","desir","destin","dev_addr","dev_eui","devic","device.","device:","device_class","device_class=lora.class_a)","differ","directly.","do:","downlink","dr:","dr=none)","dr_max)","dr_max:","dr_max=6)","dr_min,","dr_min:","dr_min=5,","driver","enabl","end","ends,","ensur","enter","etc)","etc.).","eu","eu868,","europ","event","exampl","example,","example:","examples,","examples.","examples:","except","extern","factor","factor,","factor.","fals","false)","false.","fipy.","float","float).","follow","form:","frequenc","frequency,","frequency:","frequency=868000000,","function","given","given,","goe","hand,","handl","handler","handler=lora_cb)","handler=none,","have","here","hold","hz","id","ignor","immedi","import","improp","includ","incom","index","index.","index:","indic","inform","init","initi","initialis","integers.","intern","inversion.","iq","is:","join","joined.","joined...')","keys,","khz.","know","last","last).","level","level,","level.","listen","lopi","lora","lora(mode=lora.lorawan,","lora.abp","lora.abp.","lora.add_channel","lora.add_channel(index,","lora.add_channel(index=0,","lora.always_on,","lora.as923","lora.as923,","lora.au915","lora.au915,","lora.bandwidth()","lora.bandwidth([bandwidth])","lora.bandwidth(lora.bw_125khz)","lora.bw_125khz","lora.bw_125khz,","lora.bw_250khz","lora.bw_250khz,","lora.bw_250khz.","lora.bw_500khz","lora.bw_500khz.","lora.callback(trigger,","lora.callback(trigger=(lora.rx_packet_ev","lora.class_a","lora.class_a,","lora.class_c","lora.class_c.","lora.coding_4_5","lora.coding_4_5,","lora.coding_4_6","lora.coding_4_6,","lora.coding_4_7","lora.coding_4_7,","lora.coding_4_8","lora.coding_4_8.","lora.coding_rate()","lora.coding_rate([coding_rate])","lora.coding_rate(lora.coding_4_5)","lora.eu868","lora.eu868,","lora.events()","lora.events().","lora.frequency()","lora.frequency(868000000)","lora.frequency([frequency])","lora.has_joined()","lora.has_joined().","lora.has_joined():","lora.init(mode,","lora.init(mode=lora.lora,","lora.init(mode=lora.lorawan)","lora.ischannel_free(","lora.ischannel_free(rssi_threshold)","lora.join(activation,","lora.join(activation=lora.abp,","lora.join(activation=lora.otaa,","lora.lora","lora.lora,","lora.lorawan","lora.lorawan.","lora.mac()","lora.nvram_erase()","lora.nvram_restore()","lora.nvram_save()","lora.otaa","lora.otaa,","lora.power_mode([power_mode])","lora.preamble()","lora.preamble([preamble])","lora.preamble(lora.coding_4_5)","lora.remove_channel()","lora.remove_channel(index)","lora.rx_packet_ev","lora.rx_packet_event,","lora.rx_packet_event:","lora.set_battery_level(127)","lora.set_battery_level(level)","lora.sf()","lora.sf(7)","lora.sf([sf])","lora.sleep","lora.sleep.","lora.sleep:","lora.stats()","lora.tx_failed_ev","lora.tx_onli","lora.tx_only,","lora.tx_packet_ev","lora.tx_packet_event),","lora.tx_packet_event,","lora.tx_packet_event:","lora.us915","lora.us915.","lora_cb(lora):","loraeu868.","lorawan","lorawan.","lower","mac","make","match","maximum","maximum.","mean","measur","memori","memory.","messag","method","method.","mhz","microsecond","millisecond","minimum","mode","mode)","mode,","mode.","mode:","modul","module:","ms).","name","need","network","network.","network.lora(id=0,","new","nois","non","note","number","nvram_sav","nwk_swkey","nwk_swkey,","object","object.","occur","on","one.","option","option.","optional.","optname,","order","ored):","otaa","otherwis","otherwise.","out","packet","packet.","packets).","param","paramet","performed.","perman","personalis","personalisation)","pick","place.","pleas","point","port","port)","possibl","power","power_mod","power_mode=lora.always_on,","pre","preambl","preamble=8,","precis","precision.","previous","print('lora","print('not","print(data)","privat","procedure:","processor","program","provid","public","public,","public=true,","radio","radio.","rais","rang","rate","rate.","rate:","ratio","raw","receiv","received')","received,","received.","received...","region","region=lora.eu868)","regions:","registri","relev","remov","removed,","replac","request","request.","restor","restrict","retri","retriev","return","rssi","rssi,","rssi_threshold","rx","rx_iq","rx_iq=false,","rx_timestamp","s","s.bind(1)","s.close()","s.recv(128)","s.recv(64)","s.recvfrom(128)","s.send('hello')","s.send(bytes([0x01,","s.send(bytes([1,","s.setblocking(false)","s.setblocking(true)","s.setsockopt(socket.sol_lora,","s.settimeout(5.5)","same","save","saved.","second","seconds.","see","seen","select","send","sending/receiv","sent","sent')","set","sf","sf=12)","sf=7,","sfrx","sfrx,","sftx","sftx,","signal","singl","sleep","snr","snr,","socket","socket.bind(port_number)","socket.close()","socket.recv(bufsize)","socket.recvfrom(bufsize)","socket.send(bytes)","socket.setblocking(flag)","socket.setsockopt(level,","socket.settimeout(value)","socket.so_confirmed,","socket.so_dr,","socket.sock_raw)","socket.socket(socket.af_lora,","soon","source.","specif","specifi","specification:","specified,","spread","stack","stack.","standard","state","statu","status,","store","strength","struct","struct.unpack(\">l\",","subsystem","support","symbol","symbols.","sync","take","tell","therefor","therefore,","there'","this.","those","time","time.sleep(2.5)","timeout","timeout:","timeout=0)","timestamp","transmiss","transmission.","transmissions,","transmit","transmitted.","trigger","true","true)","true,","tupl","tx","tx_counter","tx_counter,","tx_frequenc","tx_frequency)","tx_iq","tx_iq=false,","tx_onli","tx_power","tx_power,","tx_power.","tx_power=14,","tx_retri","tx_retries=1,","tx_time_on_air","tx_time_on_air,","tx_trial","tx_trials,","type","ubinascii","ubinascii.unhexlify('00000005'))[0]","ubinascii.unhexlify('11b0282a189b75b0b4d2d8c7fa38548b')","ubinascii.unhexlify('2b7e151628aed2a6abf7158809cf4f3c')","ubinascii.unhexlify('ada4dae3ac12676b')","unit","until","us","us.","us915.","usage:","used.","valu","value)","values.","values:","variou","version","version.","volatil","wait","way","way:","ways:","whenev","where:","window","windows,","without","won't","word.","work","zero)","|"],"firmwareapi/pycom/network/sigfox.html":["#","&","'","'true'","(868","(and","(devic","(e.g.","(europe)","(sipy)","(so_*","(thi","(uplink_frequency_hz,","*","+","+14dbm","+22dbm",",",".","...)","1","1')","10,","100):","11,","12","12]))","1:","2","2')","2,","20","2:","3,","3]))","4","4,","5","5,","6,","64","64.","7,","8","8,","863","9,","912","928","=","achiev","address","africa.","allow","alway","amount","antenna","antenna),","api","applic","are:","area","argentina.","argument","australia,","automat","await","band","band,","base","befor","below:","between","bi","binari","bit","block","blocking,","boolean","both","brazil.","buffer","byte","bytes.","call","capabl","card.","care","case","channel","channel.","class","close","code","colombia","come","commun","communication.","complet","configur","configuration.","connect","constant","constructor","contain","convert","correct","creat","cycl","damag","data","data,","default","defin","delay","devic","device)","device.","devices,","devices.","differ","directional,","disabl","done","down","downlink","downlink_frequency_hz)","driver","due","duti","e.g.","empti","enabl","encrypt","ensur","etc.)","etc.).","europe,","exampl","example:","examples:","exclus","exist","expect","false)","fcc","fipy.","first","flag.","flavours:","follow","form:","frequenc","frequency,","frequency=868000000)","frequency=912000000)","frequency=none)","fsk","fsk,","fsk.","fulfilled.","get","given","hardwar","hexidecim","hong","however,","human","i.e.:","id.","import","indic","init","initialis","integ","integer.","japan.","key","kong,","last","life","like:","limitations).","limitations,","lopi","low","mac","macro","make","maximum","mean","messag","message.","method","method.","mexico","mhz","mhz)","mhz.","minimum","mode","mode.","mode:","modul","modulation.","module:","narrow","necessari","need","network","network,","network.","network.sigfox(id=0,","new","normal","note:","object","object.","often),","oman","oper","option.","optname,","out","pac.","packet","packet.","packets.","param","pass","payload","payload,","piec","pleas","point","power","print(s.recv(64))","print(ubinascii.hexlify(sigfox.mac()))","procedur","processor","proper","protocol","provid","public","public_key","pycom","quick","radio","radio.","range(1,","rcz","rcz1","rcz2","rcz3","rcz4","rcz4.","rcz=sigfox.rcz1)","rcz=sigfox.rcz1,","readabl","real","receiv","region","rememb","remot","representation.","request","requir","reset","restrict","return","run","s","s.recv(32)","s.recv(64)","s.send('')","s.send('devic","s.send('hello","s.send('hello')","s.send(bytes([1,","s.setblocking(true)","s.setsockopt(socket.sol_sigfox,","s.settimeout(5.0)","same","second","see","seen","select","send","sending/receiv","sending/receiving.","sent","servers.","set","setsockopt()","sigfox","sigfox(mode=sigfox.fsk,","sigfox(mode=sigfox.sigfox,","sigfox,","sigfox.frequencies()","sigfox.fsk","sigfox.fsk.","sigfox.id()","sigfox.init(mode=sigfox.sigfox,","sigfox.mac()","sigfox.pac()","sigfox.public_key()","sigfox.public_key([public])","sigfox.public_key(true)","sigfox.rcz1,","sigfox.rcz2,","sigfox.rcz3,","sigfox.rcz4","sigfox.rcz4.","sigfox.rssi()","sigfox.sigfox","sigfox.sigfox,","sigfox.sigfox.","sign","signal","singapore,","singl","sipi","size","socket","socket,","socket.","socket.close()","socket.recv(bufsize)","socket.send(bytes)","socket.setblocking(flag)","socket.setsockopt(level,","socket.settimeout(value)","socket.so_bit,","socket.so_oob,","socket.so_rx,","socket.sock_raw)","socket.socket(socket.af_sigfox,","someth","south","specifi","standard","state","str(i))","strength","string","string,","support","sure","symbol","taiwan,","take","technology.","test","therefore,","this,","time","time.sleep(1)","timeout","transmissions.","true","true)","true:","tupl","two","tx","ubinascii","ultra","unb","until","up","uplink","upon","us","usa,","usag","valu","value)","values:","version","wait","way:","wide","without","work","zealand,","zones:"],"firmwareapi/pycom/network/lte.html":["#","(connect","(i.e.","(or","(same","...)","1.4","12,","13,","2.5","20","200","28.","2g/gprs,","3,","375","3gpp","4,","5","6","60","=","abov","access","activ","address","address.","are:","argument","around","at&t,","attach","authoris","automatically,","avail","band","band=none)","batteri","be","befor","between","both","call","card.","carrier","carrier,","carrier=none)","cat","categori","cells,","cellular","channel","check","cid","cid=1)","cid=1.","cid=3.","class","command","compat","completely.","configur","configuration.","connect","connected),","constructor","consumpt","coverag","creat","current","data","deepsleep.","def","defin","deinit()","deploy","design","detach","develop","devic","differ","directli","disabl","done","enabl","end","enter","example:","fals","featur","file.","fipi","fipy.","firmwar","flash","found","fsm","full","function","functionality.","gener","given.","gpi","gpy/fipi","hardwar","here.","iccid","id)","id.","imei","import","important:","init","insert","instance,","instruct","iot","iot,","ip","it'","kbp","khz","known","licens","life","life,","life.","line","long","longer","low","lte","lte()","lte(carrier=\"verizon\")","lte.attach(*,","lte.attach(band=13)","lte.connect(*,","lte.connect(cid=3)","lte.deinit()","lte.dettach()","lte.disconnect()","lte.iccid()","lte.imei()","lte.init(*,","lte.isattached()","lte.isattached())","lte.isattached():","lte.isconnected()","lte.isconnected():","lte.reset()","lte.send_at_cmd('at+cereg?')","lte.send_at_cmd(cmd)","lte.send_at_cmd(cmd).split('\\r\\n')","m","m/nb","m1","m1:","make","mani","manual","method","mhz","minimum.","mobil","mobility.","mode","modem","modem.","modul","monarch","move","name.","nb","nb1","need","network","network.","network.lte(id=0,","networks.","new","none)","note","note:","now","number","object","object.","obtain","obtained.","offer","older","on","oper","optimis","option","order","other","otherwise.","outperform","param","pars","paus","pdf","perform","phi","pleas","possibl","power","pretti","previou","print('attaching...')","print('connecting...')","print(line)","printing:","process","protocol","protocol.","protocols:","provid","pycom'","radio","range.","raw","reboot.","reconnect.","reduc","registr","request","requir","reset","respons","response:","restrict","resum","return","scan","scanned.","second","seconds.","see","send","send_at_cmd_pretty('at!=\"fsm\"')","send_at_cmd_pretty('at!=\"showphy\"')","send_at_cmd_pretty(cmd):","sequan","session","session.","set","sever","share","shutdown","sim","similar","size","socket","specif","specifi","specific,","specified,","spectrum,","speed.","standard","standard.","standards.","start","statu","string","subsystem.","such","support","switch","system","take","telstra","throughput","throughput.","time","time.","time.sleep(0.5)","true","two","ultra","up","up.","uplink","us","usual...","valu","veri","verizon","verizon,","verizon:","wait","whole","work","world."],"firmwareapi/pycom/aes.html":["#","(16","(advanc","(ae","(byte","(iv)","(never","(see","*","+",",","...","128","128),","128,","16","192),","192,","24","256","256)","32","=","ae","aes(key,","aes.mode_cbc:","aes.mode_cfb","aes.mode_cfb,","aes.mode_cfb.","aes.mode_cfb:","aes.mode_crt.","aes.mode_ctr.","aes.mode_ctr:","aes.mode_ecb","aes.mode_ecb.","aes.mode_ecb:","aes.segment_128","aes.segment_128:","aes.segment_8","aes.segment_8,","alway","appli","are:","argument","articl","associ","avoid","b'notsuchsecretkey'","bit","bits.","block","book.","byte","bytes)","bytes.","chain","chaining.","cipher","cipher.","cipher.decrypt(msg[16:])","cipher.encrypt(b'attack","ciphertext","class","code","constant","constructor","counter","counter,","creat","crypto","crypto.getrandbits()","crypto.getrandbits(128)","ctr","data","dawn')","decrypt","decryption.","default","differ","each","electron","encrypt","esp32","exampl","feedback.","fix","gener","hardwar","hide","ignor","implement","import","in.","info)","initialis","initialisation.","issues,","it)","iv","iv)","iv,","key","key.","length","long.","messag","messages.","method","mode","mode,","mode.","module.","more","msg","msg[:16])","never","nist.","number","object","origin","paramet","pattern","plaintext","print(original)","process","properli","purpose.","quick","random","required.","reus","reused.","same","secret","secur","segment","segment_s","segment_size)","sent","set","side","simplest","size","somewher","standard)","standardis","stream","string)","support","symmetr","two","ucrypto.aes(key,","ucrypto.decrypt()","ucrypto.encrypt()","uniqu","us","usag","use.","valu","vector","vector.","well","work"],"firmwareapi/pycom/pycom.html":["\"","\"/sd/appimg.bin\"","\"rb\")","#","%","'/sd')","(enabl","(lopi","(true","+=","0:","0x00ff00","10)","100)","24","25)","32","4096","5000","5000m","8","=",">","accept","active.","allow","alreadi","ap","appimg","applic","arbitrari","area","area.","avoid","between","bit","bits.","block","blocksiz","blue,","boolean","boot","boot,","break","bright","buffer","bytearray(blocksize)","call","card","chunk","class.","color","colour","come","const(4096)","contain","control","cycles.","data","default","devic","devices,","dht11/dht22/am2302","disabl","disabled)","durat","each","effect","else:","enabl","end=\"\")","entir","eras","exampl","example)","example:","exist","extern","f.readinto(buffer)","f:","false).","false,","featur","feed","file","file,","firmwar","flag","flag.","flash.","follow","ftp.","function","get","given","green","green.","heartbeat","heartbeat.","here","hold","imag","import","inp","instance,","instead","integ","intern","it'","key","led","led.","light","list","machin","make","memori","memoryview(buffer)","method","microsecond","milliseconds.","minimum","mode.","mode=pin.open_drain)","modul","moment.","mount","mount(sd,","ms","ms.","mv","need","new","next","non","none.","note,","nvram","object,","obvious","occur","onc","open(appimg,","open_drain","os","ota_finish","ota_finish()","ota_finish().","ota_start()","ota_start(),","ota_start,","ota_write(buffer),","ota_write(mv[:chunk])","ota_write,","part","pass","perform","perman","persist","pin","pin(\"g7\",","pin(0)","pin(1)","pin.","power","preserv","print(\"\\r%7d","process.","protocol,","puls","pulses_get","pulses_get(pin,","pycom","pycom.heartbeat()","pycom.heartbeat([enable])","pycom.heartbeat(false)","pycom.heartbeat(true)","pycom.heartbeat_on_boot([enable])","pycom.nvs_erase(key)","pycom.nvs_erase_all()","pycom.nvs_get('count')","pycom.nvs_get(key)","pycom.nvs_set('count',","pycom.nvs_set('temp',","pycom.nvs_set(key,","pycom.ota_finish()","pycom.ota_start()","pycom.ota_write(buffer)","pycom.pulses_get(pin,","pycom.rgbled(0xff00)","pycom.rgbled(color)","pycom.wdt_on_boot()","pycom.wdt_on_boot([enable])","pycom.wdt_on_boot(true)","pycom.wdt_on_boot_timeout()","pycom.wdt_on_boot_timeout(10000)","pycom.wdt_on_boot_timeout([timeout])","pycom.wifi_on_boot()","pycom.wifi_on_boot([enable])","pycom.wifi_on_boot(true)","quick","raw","read","reboots.","receiv","recommended.","reconfigur","red","red,","regularli","repres","reset","reset,","reset.","return","rgb","run","scan","script","sd","sd()","sensor","seri","server","set","set,","shall","signific","size","size,","size=0","sizes.","sleep_m","sleep_ms(20)","specif","specifi","ssid","start","state","stop","store","such","suitabl","system.","take","tell","termin","though","time","timeout","timeout)","transit","true,","true:","tuples,","until","up","updat","update.","us","usag","valu","value)","value.","veri","via","volatil","wdt","wdt_on_boot_timeout.","wifi","within","without","wlan","written","written,","xxx"],"firmwareapi/micropython/":["\"micro","avail","built","contain","core","devices.","directori","drop","example,","fallback","file","first","fit","follow","found,","found.","function","ified\"","import","intend","it'","json","json.pi","librari","libraries,","library.","list","load","micropython","micropython.","modul","module.","name","name,","name.","non","noth","overridden","packag","path.","philosophi","provid","pycom","python","replac","search","specif","standard","u","ujson"],"firmwareapi/micropython/micropython.html":["(a","(e.g.","(eg","*","+","1","1)","100","3","=","abov","absolut","access","activ","again.","alloc","amount","argument","around","attempted.","avail","be","begin","block","boot.pi","both","buffer","byte","bytes).","c","c,","c.","call","captur","case","charact","code","compil","comput","const","const(123)","const(2","const_i","const_x","constant","correspond","cpython","creat","ctrl","current","declar","default","dependent,","depth","differ","directli","disabl","dure","emerg","entir","except","exception.","execution,","execution.","express","extra","fail","follow","follows:","free.","function","give","given","global","good","hand,","handler)","heap","heap.","heap_lock()","heap_unlock()","hidden,","i.e.","implement","import","in.","includ","incom","increase,","indic","inform","integ","intern","interrupt","it.","keyboardinterrupt","level","level.","lock","main","main.py)","mainli","make","memori","memory.","memoryerror","method","micropython","micropython,","micropython.alloc_emergency_exception_buf(size)","micropython.const(expr)","micropython.heap_lock()","micropython.heap_unlock()","micropython.kbd_intr(chr)","micropython.mem_info([verbose])","micropython.opt_level([level])","micropython.qstr_info([verbose])","micropython.stack_use()","mode","modul","multipl","name","nested,","none.","normal","number","occur","optimis","otherwis","out","outsid","parser","part","particularli","pass","pattern.","place","points.","prevent","print","printed.","provid","purposes.","rais","ram","recognis","repl,","repres","restor","return","row","run","same","script","scripts,","set","situations.","size","stack","start","still","stream","string","strings.","subsequ","take","therefor","time","traceback","under","underscor","unlock","up","us","usag","use.","used.","useful,","usual","valu","variabl","variable,","verbos","way","within","written"],"firmwareapi/micropython/uctypes.html":["\"arr\":","\"arr2\":","\"b0\":","\"b1\":","\"bf\"),","\"bitf0\":","\"descriptor\"","\"field_name\":","\"foreign","\"ptr\":","\"ptr2\":","\"sub\":","(2,","(and","(correspond","(doesn't","(e.g.","(encod","(for","(foreign","(in","(it'","(note:","(or","(pack","(python","(see","(thi","(typenam","(uctypes.array","(uctypes.ptr","*","*.","0","0,","0.","0}),","1).","1,","2","2),","2,","3","8","[0]","[]","abi","abi,","abov","above,","above.","access","actual","address","address,","address.","aggreg","align","alloc","allow","allows,","alternatively,","alway","anticip","api","are:","argument","array","array,","array.","assign","associ","avoid","baremet","base","basic","be","behind","below).","bf_len","bf_po","big","binari","bit","bit,","bitfield","bitfield).","bitfield,","bitfields:","bits,","both","buffer","byte","bytearray","bytes)","bytes,","bytes.","bytes_at()","c","c.","call","captur","care","chang","class","come","complex","concis","conform","constructor.","contain","content","copi","correspond","count","cpython'","creat","ctype","current","currently,","data","data,","datasheet","decreas","defin","defines).","depend","dereferenc","dereference,","describ","descriptor","descriptor,","detail","dictionari","dictionary),","differ","different,","disabl","dot","duplic","each","ed","effectively,","element","encod","endian","endianness,","even","exactli","exampl","example,","except","explicit","extra","extract","familiar","ffi","field","field).","field.","fields.","file","first","flag","float)","follow","function","function,","function.","further","gener","get","given","hardwar","i.e.","i/o","idea","identifi","immutable,","implement","import","independ","individu","instanc","instanti","instead","integ","interface\"","interface)","intermedi","interrupt).","it'","key","languag","larg","later,","layout","layout_type=native)","layouts,","lead","length","limit","littl","lookup","mani","mcu/soc.","mcu_registers.peripheral_a.register1,","mean","memori","memory,","micropython","micropython.","modul","modules,","my_struct.substruct1.field1.","name","nativ","need","nest","network","non","normal","normalis","notation:","note","number","object","object,","object.","occupi","offset","offset,","on","oper","operator,","optimis","origin","pack","parallel","particular","particular,","pass","peripheral,","peripheral_a.register0.","peripheral_a.register1.","peripheral_a.register[0]","point","pointer","pointer,","posit","positions,","possibl","power","predefin","prefix","primit","produc","prohibited).","properti","protocol","ptr","python","read","readabl","recommend","recurs","refer","reference,","regist","registers,","rel","repres","requir","required),","respectively.","restrict","retain","return","returned).","right","rightmost","runs.","same","scalar","scale","second","semant","separ","shift","signific","similar","size","size)","size.","small","socket).","sources:","special","specif","standard","start","start.","streamlin","structur","structure\"","structure.","structures).","structures.","structures:","sub","subscript","sum","support","syntax","syntax,","system","system.","taken","target","them.","third","though","to.","too).","too,","tuple,","type","type,","type.","type:","types,","types:","uctyp","uctypes.addressof(),","uctypes.addressof(obj)","uctypes.bfuint16","uctypes.big_endian","uctypes.bytearray_at(addr,","uctypes.bytes_at(addr,","uctypes.little_endian","uctypes.n","uctypes.sizeof(struct)","uctypes.struct()","uctypes.struct(addr,","uctypes.uint32","uctypes.uint8","uctypes.uint8),","uint16","uint16,","uint16.","unlik","up,","us","usage,","ustruct","usual","valu","value,","value.","values.","variou","want","way","well","whose","within","without","words,","work","written","{","{\"b\":","|","})"],"firmwareapi/micropython/sys.html":["\">","\"big\").","\"bitness\"","\"micropython\"","#","(\"little\"","(1,","(32","(e.g.","(major,","(note","(or","(that","(v","+=","0","0)","1","16\",","31)","32","32\",","32:","64","64\"","7,","=",">",">>=","above,","actual","another.","appear","argument","attribut","attributes:","bare","baremet","bit","bit,","board","board,","board.","builtin","byte","case","check","code.","compar","comparisons.","compat","conform","constant","count","cpython","cpython.","current","default).","describ","detect","dictionari","differ","directly,","directori","distinguish","due","e.g.","else:","error","etc.).","except","exception.","exist","exit","file","file=sys.stdout)","follow","found","function","further","given","given,","hold","identifi","implement","implementation),","implementation.","import","includ","inform","input","instead","instead.","int","integ","ints.","it:","it'","languag","less","less)","lib.","linux.","list","load","long","mandat","max","maximum","method","micro),","micropython","micropython,","micropython.","minim","minimum","minor,","modul","modules.","more","more)","mutabl","name","nativ","need","note","number","object","object,","object;","on","on.","order","origin","os,","os/rto","output","peculiar","platform","platform,","port","ports).","ports,","positional;","print","program","pyboard","python","rais","recommend","refer","represent","run","search","simplifi","smaller","standard","start","still","stream.","string","string.","style","support).","supported.","sy","sys.argv:","sys.byteorder:","sys.exit(retval=0)","sys.implement","sys.implementation:","sys.maxs","sys.maxsize:","sys.modules:","sys.path:","sys.platform:","sys.print_exception(exc,","sys.stderr:","sys.stdin:","sys.stdout","sys.stdout:","sys.version:","sys.version_info:","system","systemexit","systemexit.","take","termin","thu","to,","traceback","traceback.print_exception(),","tupl","type","type,","underlyingly,","unlik","us","usual","v","v:","valu","value,","veri","version","vs","way","whether","with.","without"],"firmwareapi/micropython/uos.html":["'/sd')","(if","(in","(like","(not","(the","*",",","/","/flash","/sd","/sd.","0)","10","access","access.","alia","argument,","avail","be","befor","bits.","block","byte","bytes.","card","chang","change.","charact","constant","contain","content","creat","current","currently:","devic","device.","directori","directory.","drive","duplic","example:","exists)","file","file.","filesystem","filesystems.","firmwar","flash","follow","format","free","function","function.","given","group","hard","here.","id","implement","implemented,","inform","inod","intern","interpret","kib)","links.","list","metadata","method","method.","methods.","micropython","modification.","modul","mount","mount_point,","mounted.","n","new","new_path)","number","number.","object","object)","object.","order:","os.mount(sd,","otherwis","owner.","pass","path","path)","path,","path.","physic","point.","port","previous","protect","random","read()","readonly=false)","recent","releas","remov","remove()","renam","repl)","return","root","sd","separ","size","space","specif","specifi","st_atime:","st_ctime:","st_dev:","st_gid:","st_ino:","st_mode:","st_mtime:","st_nlink:","st_size:","st_uid:","statu","stream","sync","system,","termin","time","tupl","unmount","uo","uos.chdir(path)","uos.dupterm(stream_object)","uos.getcwd()","uos.getfree(path)","uos.listdir([dir])","uos.mkdir(path)","uos.mkfs(block_devic","uos.mount(block_device,","uos.remove(path)","uos.rename(old_path,","uos.rmdir(path)","uos.sep:","uos.stat(path)","uos.sync()","uos.uname()","uos.unlink(path)","uos.unmount(path)","uos.urandom(n)","urandom","us","user","valu","values,","version,","version.","write()","–"],"firmwareapi/micropython/array.html":["(the","2","append","array","array,","array.append(val)","array.array(typecode[,","array.extend(iterable)","b,","class","codes:","contain","content","creat","created.","d","depend","element","empti","end","f,","float","format","given","grow","h,","i,","information.","initi","it.","iter","iterable.","iterable])","l,","latter","method","more","new","point","provided,","python","q,","see","support","support).","type."],"firmwareapi/micropython/cmath.html":["(","+pi).","10","along","axis.","base","basic","branch","circle'","circumfer","cmath","cmath.cos(z)","cmath.e:","cmath.exp(z)","cmath.log(z)","cmath.log10(z)","cmath.phase(z)","cmath.pi:","cmath.polar(z)","cmath.rect(r,","cmath.sin(z)","cmath.sqrt(z)","complex","constant","cosin","cut","diamet","exponenti","float","form","function","logarithm","mathemat","method","modul","module.","modulu","natur","neg","number","numbers.","phase","phi)","phi.","pi,","point","polar","provid","r","rang","ratio","real","requir","return","returns,","root","sine","squar","support","tuple,","work","z,","z."],"firmwareapi/micropython/math.html":["(0.0,","(2**exp).","(m,","*","0","0),","0.","0.5","1.","10","2","2**e","==","absolut","base","basic","be","both","circle'","circumfer","complementari","constant","convert","cosin","decompos","degre","degrees.","diamet","e)","error","exactly.","exp(x)","exp)","exponent.","exponenti","finite.","float","floats,","fraction","function","gamma","holds.","hyperbol","infinite.","infinity.","integer,","integr","invers","logarithm","m","mantissa","math","math.acos(x)","math.acosh(x)","math.asin(x)","math.asinh(x)","math.atan(x)","math.atan2(y,","math.atanh(x)","math.ceil(x)","math.copysign(x,","math.cos(x)","math.cosh(x)","math.degrees(x)","math.e:","math.erf(x)","math.erfc(x)","math.exp(x)","math.expm1(x)","math.fabs(x)","math.floor(x)","math.fmod(x,","math.frexp(x)","math.gamma(x)","math.isfinite(x)","math.isinf(x)","math.isnan(x)","math.ldexp(x,","math.lgamma(x)","math.log(x)","math.log10(x)","math.log2(x)","math.modf(x)","math.pi:","math.pow(x,","math.radians(x)","math.sin(x)","math.sinh(x)","math.sqrt(x)","math.tan(x)","math.tanh(x)","math.trunc(x)","mathemat","method","modul","module.","natur","neg","number","numbers.","otherwis","part","point","posit","power","princip","provid","radian","radians.","ratio","relat","remaind","requir","return","root","round","same","sign","sine","squar","such","support","tangent","toward","true","tupl","two","valu","work","x","x)","x.","x/y.","y)","y.","y/x."],"firmwareapi/micropython/gc.html":["allocated,","allocated.","automat","avail","byte","collect","collection.","disabl","enabl","garbag","gc","gc.collect()","gc.collect().","gc.disable()","gc.enable()","gc.mem_alloc()","gc.mem_free()","heap","initi","manual","memori","method","number","ram","ram.","return","run","still","us"],"firmwareapi/micropython/ubinascii.html":["(i.e.","(in","addit","argument,","ascii","base64","between","binari","both","byte","convers","convert","cpython","data","differ","directions).","encod","form","format.","hexadecim","hexlify)","implement","invers","method","modul","representation.","return","sep","sep])","separ","string.","supplied,","ubinascii","ubinascii.a2b_base64(data)","ubinascii.b2a_base64(data)","ubinascii.hexlify(data[,","ubinascii.unhexlify(data)","us","values.","variou"],"firmwareapi/micropython/ujson.html":["(a",".read()","allow","between","contain","content","convert","correctli","data","document).","file","format.","formed.","fp","json","method","modul","obj","object","object.","pars","python","rais","repres","return","str","string","string.","support","ujson","ujson.dumps(obj)","ujson.load(fp)","ujson.loads(str)","valueerror"],"firmwareapi/micropython/ure.html":["$","(and","(which","({m,n}),","*","*?","+","+?",".","0","1)","?","??","[]","^","actual","advanc","against","alway","anchored).","are:","assertions,","charact","character.","characters.","class","compil","count","cpython","creat","debug","display","etc.","express","expression,","expression.","expressions).","extend","first","flag","group","groups,","happen","implement","individu","inform","instanc","match","match()","match,","match.group([index])","max_split=","method","methods.","modul","more","name","numer","object","object.","oper","operations.","posit","posix","rang","re","regex","regex.match(string)","regex.search(string)","regex.split(string,","regular","repetit","return","search","search()","set","start","still","string","string)","string.","subset","support","supported.","syntax","unlik","ur","ure.compile().","ure.compile(regex)","ure.debug","ure.match(regex,","ure.search(regex,","us","value,"],"firmwareapi/micropython/usocket.html":["(after","(bytes,","(conn,","(family,","(if","(ipv4_address,","(rb","(so_*","0","0);","1","1])","5","65535.","8.8.8.8,","80)[0][","=","accept","access","address","address)","address,","address.","alia","allow","alreadi","amount","argument","arguments:","around","associ","automat","avail","backlog","befor","behav","below","below.","binari","bind","block","blocking,","bound","bound.","bsd","buf.","buffer","buffer.","bufsize.","byte","bytes.","calls:","canonname,","case","certain","character.","chosen.","class","close","close()","closed.","collected,","comparison.","completed.","conn","connect","connection,","connection.","connections.","constant","contain","correspond","cpython","cpython'","creat","data","data.","default","defin","depend","destin","differ","domain","dot","e.g.","elaps","enabl","encoding,","end","eof.","equival","errors,","etc.).","exact","exampl","except","expect","explicitly,","express","fail.","false,","famili","family,","file","first","flag","float","flushed).","follow","format","format(s)","function","futur","garbag","given","given,","happens,","host/port","inconsist","instance:","integ","interface.","intern","ip","ipv4","ipv4_address","ipv4_address,","it'","layers:","len(buf)","limit","line","line,","list","listen","lora","lower,","makefile()","makefile().","mani","mark","maximum","method","mode","mode.","mode;","modul","more","name","nbyte","nbytes])","necessari","need","network","new","newlin","non","none","none.","nonneg","notat","note","number","number,","number.","numer","object","object.","object'","occurs.","onc","oper","operations.","option","option.","options:","optname,","origin","otherwise,","pair","paramet","period","point","port","port)","port),","port.","proto,","protocol","protocols:","provid","put","queu","rais","rang","read","read.","reason","receiv","received.","recommend","refus","remot","repres","resolv","return","s","s.bind(1)","s.connect(socket.getaddrinfo('www.micropython.org',","seconds,","see","send","sequenc","server","service.","set","settimeout()","shorthand","show","sigfox","simpli","size","sock.setblocking(false)","sock.setblocking(true)","sock.settimeout(0.0)","sock.settimeout(none)","sockaddr)","socket","socket,","socket.","socket.accept()","socket.af_inet,","socket.af_lora","socket.bind(address)","socket.close()","socket.connect(address)","socket.error,","socket.getaddrinfo().","socket.getaddrinfo(host,","socket.ipproto_tcp","socket.ipproto_tcp)","socket.ipproto_udp,","socket.listen([backlog])","socket.makefile(mode='rb')","socket.read(size)","socket.readall()","socket.readall(),","socket.readinto(buf[,","socket.readline()","socket.recv(bufsize)","socket.recvfrom(bufsize)","socket.send(bytes)","socket.send(bytes).","socket.sendall(bytes)","socket.sendto(bytes,","socket.setblocking(flag)","socket.setsockopt(level,","socket.settimeout(value)","socket.so_bit","socket.so_confirmed,","socket.so_dr","socket.so_oob,","socket.so_reuseaddr","socket.so_rx,","socket.so_tx_repeat,","socket.sock_dgram,","socket.sock_raw","socket.sock_stream,","socket.socket()","socket.socket(socket.af_inet,","socket.sol_lora,","socket.sol_sigfox","socket.sol_socket,","socket.timeout","socket.write(buf)","socket:","sockets,","specifi","specified,","state","statement","store","string","structure:","subsequ","support","supported.","symbol","system","them.","timeout","timeout,","translat","tupl","type","type,","types:","unaccept","until","up","url:","us","usabl","usocket","valu","value)","value:","wb).","well.","write","written.","zero"],"firmwareapi/micropython/select.html":["(obj,","(select","...)","2.","above.","activ","are:","assum","avail","becom","case","class","class.","combin","compat","constant","creat","current","data","default","depend","describ","detect","don't","effici","efficient.","element","empti","end","error","event","event,","eventmask","eventmask)","eventmask])","function","happen","instanc","instead.","list","logic","method","milliseconds.","modifi","modul","more","multipl","obj","obj.","object","objects.","occur","of:","on","operations).","platform","poll","poll.modify(obj,","poll.poll([timeout])","poll.register(obj[,","poll.unregister(obj)","polling.","provid","pyb.uart,","pyb.usb_vcp.","pyboard","read","read/writ","readi","ready.","recommend","regist","return","returned.","select","select.poll()","select.poll*","select.pollerr","select.pollhup","select.pollin","select.pollout","select.pollout.","select.select(rlist,","set","size","specif","specifi","stream","stream/connect","support","termin","timeout","timeout,","timeout])","tuple,","tuples,","unregist","usag","version,","wait","way","wlist,","written","xlist[,","|"],"firmwareapi/micropython/utime.html":["\"new\"","\"old\"","#","(becaus","(for","(includ","(mani","(requir","(rtc).","(see","(which","(year,","+","0","0.","00:00:00","01","0:","1","1,","12","1970","2000.","2014).","23","31","366","500:","500u","59","6","8","=","==",">","above)","above,","absolut","accept","actual","additional,","again","api","application,","arbitrarili","argument","argument,","around","asserted,","assum","backup","baremet","batteri","behav","below","better","between","board","board).","calendar","call","case).","centuri","choice.","clock","compat","compon","consecut","contains:","convert","current","date,","date/tim","date/time.","delay","delays.","depend","develop","directli","done","each","epoch","epoch,","epoch:","esp32","event","exampl","expect","expected.","express","faster.","float","follow","fraction","full","function","function,","functions,","functions.","get","given","gmtime()","gpio","hard","higher","hour","hour,","implement","implicit.","includ","instead.","integ","integer,","intervals,","invers","it'","jan","local","local_tim","localtime()","localtime.","long","machine.rtc()","machine.rtc().datetime(tuple)","maintain","manual","mday","mday,","means:","measur","method","micropython","micropython,","microseconds,","microseconds.","milliseconds,","milliseconds.","minut","minute,","modul","mon","month","month,","need","network","new)","none,","note","number","object.","offset,","opposit","option","os","os/rto","outsid","particular","pattern","per","period","period).","pin","pin.value()","point","poll","port","port/user).","portabl","posit","posix","power","preced","precision,","precision.","protocol","provid","provided,","pycom'","python,","python.","queri","rais","real","refer","reli","requir","reset).","resets,","respons","result","return","rtc","rtc,","rtos),","same","sec","second","second,","seconds,","seconds.","set","set,","set.","setup","short","sleep","sleep_ms()","sleep_us()","standard","start","subtract","such","sun","supported.","system","system/micropython","though","ticks_*()","ticks_cpu().","ticks_diff()","ticks_m","ticks_ms()","ticks_ms(),","ticks_us()","ticks_us(),","ticks_us,","time","time,","time.","time.ticks_diff(start,","time.ticks_us()","time.ticks_us())","time.timezon","timeout:","timeouterror","timezon","timezone,","timezone.","tupl","undefined.","underli","up","uptime,","us","usag","used.","user","usual","utc","utc.","utim","utime.gmtime([secs])","utime.localtime([secs])","utime.mktime()","utime.sleep(seconds)","utime.sleep_ms(ms)","utime.sleep_us(us)","utime.ticks_cpu()","utime.ticks_diff(old,","utime.ticks_ms()","utime.ticks_us()","utime.time()","utime.timezone([secs])","valu","value.","wait","want","way","weekday","weekday,","without","work","wrap","write","year","yearday","yearday)"],"firmwareapi/micropython/uhashlib.html":["1","224","256","384","512","achiev","activ","algorithms.","binari","byte","called,","class","constructor","creat","data","effect.","fed","feed","hardware,","hash","hash,","hash.","hash.digest()","hash.hexdigest()","hash.update(data)","hasher","implement","implemented.","it.","limit","longer.","md5","method","modul","more","object","object.","on","oper","option","pass","return","sha","similar","support","supported.","through","time.","ubinascii.hexlify(hash.digest())","uhashlib","uhashlib.md5([data])","uhashlib.sha1([data])","uhashlib.sha224([data])","uhashlib.sha256([data])","uhashlib.sha384([data])","uhashlib.sha512([data])","us"],"firmwareapi/micropython/ussl.html":["\"secur","(often","/flash/cert/.","1])","443)[0][","8441)[0][","=","access","authent","blynk","both","ca.pem","ca_certs='/flash/cert/ca.pem')","ca_certs=none)","cert_req","cert_reqs=cert_none,","cert_reqs=ssl.cert_required,","certfile=none,","certif","certificates,","client","connect","connection,","constant","context.","do:","encrypt","end.","exampl","example:","except","facil","file","folder","ftp","import","inherit","instanc","instance,","keyfile=none,","known","layer","layer\")","locat","method","modul","module.","names.","network","order","ourselv","path","peer","place","provid","put","return","s","secur","see","server","server,","server_side=false,","side","side.","sock","socket","socket.socket()","socket.socket,","sockets,","specif","ss","ss.connect(socket.getaddrinfo('cloud.blynk.cc',","ss.connect(socket.getaddrinfo('www.google.com',","ssl","ssl.cert_none,","ssl.cert_optional,","ssl.cert_required:","ssl.sslerror","ssl.sslsocket,","ssl.wrap_socket(s)","ssl.wrap_socket(s,","ssl.wrap_socket(sock,","standard","store","subtyp","such","support","take","transport","underli","us","usocket","ussl","valid","valu","wrap"],"firmwareapi/micropython/ucrypto.html":["\"...","\"these","32","accord","advanc","ae","algorithms.","base","basi","bit","bits.","bt","business.","byte","class","crypto.getrandbits(bits)","cryptograph","cryptographi","decreas","depend","disabled,","do","document","encrypt","esp32","fi","fi/bt","fill","gener","generator.","give","hardwar","import","information.","it'","loos","manual,","method","modul","multipl","nativ","nearest","nois","number","numbers.\"","object","obtain","operations\".","out","paramet","pleas","provid","pseudo","pycrypto.","quickli","random","refer","result","return","rf","round","secur","security.","standard","subject","such","support","system.","technic","thing","trivial","true","ucrypto","upward","us","way","wi","wrong","yourself"],"firmwareapi/micropython/ustruct.html":["!.","(the",",","...","...)","2","@,","accord","b,","buffer","buffer,","buffer.","byte","codes:","count","d","data","data)","data,","depend","encod","end","f,","float","fmt","fmt.","format","given","h,","i,","information.","l,","latter","method","more","need","neg","number","object","offset","offset,","offset.","offset=0)","order","p,","pack","point","prefixes:","python","q,","return","s,","see","size/byt","start","store","string","struct","support","support).","tupl","unpack","ustruct","ustruct.calcsize(fmt)","ustruct.pack(fmt,","ustruct.pack_into(fmt,","ustruct.unpack(fmt,","ustruct.unpack_from(fmt,","v1,","v2,","valu","values."],"firmwareapi/micropython/_thread.html":["%","%d'","(4kib).","(also","(but","(i","(in","(onli","(use","(which","+","0","1)","1,","4096","4kib","=","_thread","_thread.allocate_lock()","_thread.exit()","_thread.get_ident()","_thread.locktyp","_thread.stack_size([size])","_thread.start_new_thread(function,","_thread.start_new_thread(th_func,","a_lock","a_lock:","above.","acquir","action","addit","anoth","arg","args[,","argument","argument,","arguments.","befor","below.","between","binari","bytes)","call","caught,","caus","class","configur","continu","control","cooki","creat","created.","current","data","data.","def","default)","depend","describ","dictionari","direct","e.g.","e.g.:","earlier,","error","exampl","except","exception,","exception.","execut","executes\")","existence).","exit","exits.","fals","float","follow","function","global","guarante","i))","id)","id):","identifi","identifier.","immedi","import","index","initi","integ","integer.","intend","interpret","itself.","keyword","kwarg","kwargs])","level","light","list","lock","lock.","lock.acquire(waitflag=1,","lock.locked()","lock.release()","lock:","low","magic","maximum","meaning;","method","methods,","methods:","minimum","modul","multipl","mutex","necessari","necessarili","neg","new","nonzero","nonzero,","not.","object","object.","objects.","occur","on","option","platform","point","posit","positive,","present","present,","primit","print","print(\"a_lock","print('run","process","provid","provided.","quick","rais","raised.","range(2):","reason","recycl","releas","return","returning.","returns,","run).","runtimeerror","same","second","semaphores)","share","silent","silently.","simpl","size","space","space.","specif","specifi","stack","start","statement,","statu","subsequ","successfully,","suffici","support","synchronis","synchronisation,","systemexit","tasks)","termin","th_func(delay,","that'","thread","thread,","thread.","threads,","threads.","time","time.sleep(delay)","timeout","timeout=","trace","true","true:","tuple).","type","unbound","uncondition","unconditionally,","unhandl","unlocked.","until","us","usag","valu","value:","via","wait","wait.","waitflag","waiting,","weight","without","work","zero,","zero.","—"],"firmwareapi/micropython/builtin.html":["abs()","all()","any()","avail","bin()","bool","builtin","byte","bytearray","callable()","chr()","class","compile()","complex","describ","dict","dir()","divmod()","enumerate()","eval()","exec()","filter()","float","frozenset","function","getattr()","globals()","hasattr()","hash()","here.","hex()","id()","input()","int","isinstance()","issubclass()","iter()","len()","list","locals()","map()","max()","memoryview","method()","min()","module.","next()","object","oct()","open()","ord()","pow()","print()","property()","range()","repr()","reversed()","round()","set","setattr()","sorted()","staticmethod()","str","sum()","super()","tupl","type()","via","zip()"],"firmwareapi/notes.html":[".callback()","16","2","alarm","alloc","allow","along","appropri","argument.","associ","attend","bear","both","callback","callback,","called.","class","classes.","creat","current","currently,","default","detail","differently.","done","enabl","esp32","even","event","event.","example,","examples,","given","handl","handler","handler.","happens,","ideal","insid","interrupt","interrupts.","interrupts;","keep","limit","memori","messag","method","micropython","mind","minimum","more","network","new","note","notifi","object","order","packets.","pin","pleas","port","possibl","post","process","provid","pycom'","queue","queue,","rais","receiv","regist","requir","respect","restrict","sections.","send","separ","sequenti","short","sockets.","such","support","system","thread","thu","time.","up","us","usag","user","variables,","visit","whatev","within"],"datasheets/introduction.html":["board","contain","develop","each","exampl","examples:","expans","follow","inform","introduct","modul","notes.","oem","page","pinouts,","product,","relat","relev","sheets,","shield","spec"],"datasheets/development/":["2.0","3.0,","4,","contain","datasheet","develop","devices.","fipy.","gpy,","includ","lopi","lopy,","modul","pycom","section","sipy,","wipi"],"datasheets/development/wipy2.html":["\"deep","(clk,","(sda,","(tx1/rx1),","**","****","10ma.","10ua","10ua.","2","2.0","2ma","3.3v","3.5v","4","5.5v.","7ua","access","allow","alongsid","alway","around","assign","attach","avail","between","ble","board","boot","caus","chang","chip","click","configured.","connect","consum","consumpt","control","coupl","creat","cs","current","current.","cut","damaged.","datasheet","dc","deep","default","default,","depend","design","devic","device.","digit","discontinued,","documentation.","doesn't","domain,","down","draw","due","dure","eco","enabl","enter","exampl","feed","file.","flash","float","follow","found","get","goe","hand","here","high","i2c","interest","interrupt.","issu","keep","lowest","miso)","mode","mode,","modul","more","mosi,","note","number,","only,","otherwis","out","output","password","pdf","perform","pin","pinout","pleas","point","possibl","power","provid","put","pwm","quiescent","random","rang","re","regul","rippl","rtc","scl)","section","see","shield","shield\"","sleep","sleep.","software.","sourc","specif","spi","ssid","started:","stay","store:","suppli","switch","therefor","timer","tutori","uart1","unfortunately,","upon","us","usabl","use.","via","vin","voltag","wake","wifi","wipi","wipy2","wipy2,","wipy2:","wipy3","wlan","work","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/wipy3.html":["(clk,","(p12)","(sda,","(tx1/rx1),","**","****","19.7µa","2.0","3.0","3.3v","3.5v","4","4mb","5.5v.","512kb","8mb","access","antenna","application.","assign","avail","avoid","between","ble","board","boot","buy","chang","click","connect","creat","current","damaged.","datasheet","deep","default","default,","differ","digit","disabl","documentation.","draw","exampl","extern","feed","file.","fixed,","flash","follow","found","get","gpio16","gpio21","hand","here","i2c","interest","miso)","modul","mosi,","move","note","now","number,","only,","otherwis","output","p12","p12,","password","pdf","pin","pinout","pleas","point","power","ram","random","rang","reason","regul","rf","scl)","section","select","sleep","software.","specif","spi","ssid","started:","store:","suppli","switch","tutori","uart1","unless","upgrad","upon","us","vin","voltag","wifi","wipi","wipy3","wipy3,","wipy3:","wlan","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/lopy.html":["\"deep","(clk,","(sda,","(tx1/rx1),","**","****","10ma.","10ua","10ua.","2ma","3.3v","3.5v","4","5.5v.","7ua","access","allow","alongsid","alway","around","assign","attach","avail","between","ble","board","boot","buy","caus","chang","chip","click","configured.","connect","consum","consumpt","control","coupl","creat","cs","current","current.","cut","damaged.","datasheet","dc","deep","default","default,","depend","design","devic","device.","digit","documentation.","doesn't","domain,","down","draw","due","dure","eco","enabl","enter","exampl","feed","file","file.","flash","float","follow","found","gateway","get","goe","hand","here","high","i2c","interest","interrupt.","issu","keep","lopi","lopy,","lopy:","lorawan","lowest","miso)","mode","mode,","modul","more","mosi,","nano","node","note","number,","only,","otherwis","out","output","password","pdf","perform","pin","pinout","pleas","point","possibl","power","provid","put","pwm","quiescent","random","rang","re","regul","rippl","rtc","scl)","section","shield","shield\"","sleep","sleep.","software.","sourc","specif","spi","ssid","started:","stay","store:","suppli","switch","therefor","timer","tutori","uart1","unfortunately,","upon","us","usabl","use.","via","vin","voltag","wake","wifi","wlan","work","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/lopy4.html":["(clk,","(sda,","(tx1/rx1),","**","****","3.3v","3.5v","4","5.5v.","access","antenna","application.","assign","avail","avoid","between","ble","board","boot","buy","chang","click","connect","creat","damaged.","datasheet","default","default,","digit","disabl","documentation.","exampl","extern","feed","file","file.","follow","found","gateway","get","hand","here","i2c","interest","lopi","lopy4","lopy4,","lopy4:","lorawan","miso)","modul","mosi,","nano","node","note","number,","only,","otherwis","output","p12","p12,","password","pdf","pin","pinout","pleas","point","power","random","rang","reason","regul","rf","scl)","section","select","sigfox","software.","specif","spi","ssid","started:","store:","suppli","switch","tutori","uart1","unless","upon","us","vin","voltag","wifi","wlan","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/sipy.html":["\"deep","(clk,","(sda,","(tx1/rx1),","**","****","10ma.","10ua","10ua.","2ma","3.3v","3.5v","4","5.5v.","7ua","access","allow","alongsid","alway","around","assign","attach","avail","between","ble","board","boot","buy","caus","chang","chip","click","configured.","connect","consum","consumpt","control","coupl","creat","cs","current","current.","cut","damaged.","datasheet","dc","deep","default","default,","depend","design","devic","device.","digit","documentation.","doesn't","domain,","down","draw","due","dure","eco","enabl","enter","exampl","feed","file","file.","flash","float","follow","found","get","goe","hand","here","high","i2c","interest","interrupt.","issu","keep","lowest","miso)","mode","mode,","modul","more","mosi,","note","number,","only,","otherwis","out","output","password","pdf","perform","pin","pinout","pleas","point","possibl","power","provid","put","pwm","quiescent","random","rang","re","regul","rippl","rtc","scl)","section","shield","shield\"","sigfox","sipi","sipy,","sipy:","sleep","sleep.","software.","sourc","specif","spi","ssid","started:","stay","store:","suppli","switch","therefor","timer","tutori","uart1","unfortunately,","upon","us","usabl","use.","via","vin","voltag","wake","wifi","wlan","work","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/gpy.html":["(clk,","(sda,","(tx1/rx1),","**","****","3.3v","3.5v","4","5.5v.","access","antenna","application.","assign","avail","avoid","between","ble","board","boot","buy","cat","chang","click","command","connect","creat","damaged.","datasheet","default","default,","digit","disabl","documentation.","draw","exampl","extern","feed","file","file.","follow","found","get","gpi","gpy,","gpy:","hand","here","i2c","interest","iot","lte","m","m1","miso)","modem","modul","monarch","mosi,","nb","note","number,","only,","otherwis","output","p12","p12,","password","pdf","pin","pinout","pleas","point","power","random","rang","reason","regul","rf","scl)","section","select","sequan","software.","specif","spi","ssid","started:","store:","suppli","switch","tutori","uart1","unless","upon","us","vin","voltag","wifi","wlan","www.pycom.io.","xxxx","xxxx,"],"datasheets/development/fipy.html":["(clk,","(sda,","(tx1/rx1),","**","****","3.3v","3.5v","4","5.5v.","access","antenna","application.","assign","avail","avoid","between","ble","board","boot","buy","cat","chang","click","command","connect","creat","damaged.","datasheet","default","default,","digit","disabl","documentation.","draw","exampl","extern","feed","file","file.","fipi","fipy,","fipy:","follow","found","gateway","get","hand","here","i2c","interest","iot","lorawan","lte","m","m1","miso)","modem","modul","monarch","mosi,","nano","nb","node","note","number,","only,","otherwis","output","p12","p12,","password","pdf","pin","pinout","pleas","point","power","random","rang","reason","regul","rf","scl)","section","select","sequan","sigfox","software.","specif","spi","ssid","started:","store:","suppli","switch","tutori","uart1","unless","upon","us","vin","voltag","wifi","wlan","www.pycom.io.","xxxx","xxxx,"],"datasheets/oem/":["contain","datasheet","devices.","g01.","includ","l01,","l04,","modul","oem","pycom","section","w01,"],"datasheets/oem/w01.html":["(clk,","(sda,","(tx1/rx1),","assign","avail","ble","chang","connect","datasheet","default","documentation.","draw","exampl","file","file.","follow","found","i2c","interest","miso)","modul","mosi,","note","pdf","pin","pinout","pleas","scl)","section","software.","specif","spi","tutori","uart1","w01","w01:","wifi"],"datasheets/oem/l01.html":["(clk,","(sda,","(tx1/rx1),","assign","avail","ble","chang","connect","datasheet","default","documentation.","draw","exampl","file","file.","follow","found","gateway","i2c","interest","l01","l01:","lorawan","miso)","modul","mosi,","nano","node","note","pdf","pin","pinout","pleas","scl)","section","software.","specif","spi","tutori","uart1","wifi"],"datasheets/oem/l04.html":["(clk,","(sda,","(tx1/rx1),","assign","avail","ble","chang","connect","datasheet","default","documentation.","draw","exampl","file","file.","follow","found","gateway","i2c","interest","l04","l04:","lorawan","miso)","modul","mosi,","nano","node","note","pdf","pin","pinout","pleas","scl)","section","sigfox","software.","specif","spi","tutori","uart1","wifi"],"datasheets/oem/g01.html":["(clk,","(sda,","(tx1/rx1),","assign","avail","ble","cat","chang","command","connect","datasheet","default","documentation.","draw","exampl","file","file.","follow","found","g01","g01:","i2c","interest","iot","lte","m1","miso)","modem","modul","monarch","mosi,","nb","note","pdf","pin","pinout","pleas","scl)","section","sequan","software.","specif","spi","tutori","uart1","wifi"],"datasheets/oem/l01_reference.html":["2.4ghz","3.5","5.5","abil","accommod","altium","antenna","avail","baseboard","bluetooth,","board","both","button","connection.","connector","connector.","current","dc","deep","design","doubl","draw","dure","extern","featur","file","file.","g01","g01,","gerber","input","l01","l01'","l04","layout","layout/gitbook/assets/l01","layout.pdf)","led","lora","low","make","mode","modul","modules.","oem","output.","pcb","pdf","pleas","possibl","project","refer","regul","requir","reset","rgb","schemat","sim","singl","sleep","slot","suit","suitabl","switch","u.fl","univers","us","via","w01","well","wifi","ws2812b","zip"],"datasheets/oem/universal_reference.html":["(l01,","2.4ghz","3","3.5","5.5","abil","accommod","altium","antenna","avail","baseboard","bluetooth,","board","button","connector","connector.","contain","current","dc","deep","design","draw","dure","extern","featur","file","file.","g01","g01)","g01,","gerber","input","l01","l01,","l04","l04,","layout","led","low","make","mode","modul","modules,","modules.","necessari","oem","output","pcb","pdf","possibl","project","refer","regul","requir","reset","rgb","schemat","sim","singl","sleep","slot.","suit","suitabl","suitable.","switch","u.fl","univers","via","w01,","wifi","ws2812b","zip"],"datasheets/boards/":["board","board,","contain","datasheet","deep","expans","includ","pycom","pysens","pytrack,","section","shield","shield.","shields.","sleep"],"datasheets/boards/expansion3.html":["\"safe","(connect","(if","100ma.","10k","3","3.0","3.3v","3v3).","450ma.","ad","allow","altium","application,","automat","avail","batteri","battery,","be","between","board","boards.","boot","boot\"","boot.","bootload","break","button","card","cell","charg","charger","charger.","chg","chip","connect","connected).","connector","connector,","connector.","current","custom","datasheet","dfu","differ","difficult","easier.","enter","expans","featur","file","file.","firmwar","fix.","ftdi","gentl","gerber","held","high","ion/li","jumper","li","lower","micro","mode,","mode.","modul","module,","oem","p12","p8/g15","pdf","perform","pic","pinout","plugging/unplug","po","power","present","press","program","project","pull","put","pycom","pysense/pytrack/pyscan","rel","remov","replac","reset","safe","sd","singl","solder","stay","strong,","tool","troubleshoot","up.","updat","us","usb","util","v2.0","v3.0","valu","veri","via","want","well,","whilst"],"datasheets/boards/pytrack.html":["(if","avail","batteri","be","board","cell","charg","charger","charger.","connected).","connector,","datasheet","featur","file","file.","ion/li","li","micro","pdf","pinout","po","power","pytrack","singl","usb","via"],"datasheets/boards/pysense.html":["(if","avail","batteri","be","board","cell","charg","charger","charger.","connected).","connector,","datasheet","featur","file","file.","ion/li","li","micro","pdf","pinout","po","power","pysens","singl","usb","via"],"datasheets/boards/pyscan.html":["(if","01","151","329al","7","acceleromet","accelerometer:","ad","ambient","avail","batteri","be","being,","board","cell","charg","charger","charger.","compon","components:","connected).","connector,","current","datasheet","driver","due","featur","file","file.","fix","ftp","here","here.","ion/li","li","librari","light","limit","lis2hh12","lite","locat","ltr","mfrc630.mpi","mfrc63002hn,","micro","nxp","oper","pdf","pinout","po","power","pymakr","pyscan","reader","reader:","recommend","required.","rest","rfid/nfc","sensor:","shortly.","singl","soon.","st","system","there'","time","upload","us","usb","via","window"],"datasheets/boards/expansion2.html":["(if","100ma.","2","2.0","450ma.","application,","avail","batteri","be","board","break","cell","charg","charger","charger.","chg","connected).","connector","connector,","connector.","current","datasheet","difficult","expans","featur","file","file.","fix.","gentl","high","ion/li","jumper","li","lower","micro","pdf","pinout","plugging/unplug","po","power","present","rel","remov","singl","solder","strong,","usb","valu","veri","via","whilst"],"datasheets/boards/deepsleep/":["2.0,","align","avail","board","connect","correctli","deep","devic","device.","expans","file","file.","led","lopi","onc","onto","pdf","pinout","pycom","schemat","seat","shield","shield,","sipi","sleep","triangl","white","wipi"],"datasheets/boards/deepsleep/api.html":["#","'p18'])","'p18'].","(e.g.","(i.e.","(see","/lib","3.3v,","60","=","==","['p17',","accelerometer,","ad","allow","api","associ","available,","batteri","be","below","board","board'","button).","cell)","chapter","class","constructor","contribut","control","creat","critic","deep","deepsleep","deepsleep()","deepsleep.disable_pullups(pins)","deepsleep.disable_wake_on_fall(pins)","deepsleep.disable_wake_on_raise(pins)","deepsleep.enable_auto_poweroff()","deepsleep.enable_pullups(pins)","deepsleep.enable_wake_on_fall(pins)","deepsleep.enable_wake_on_raise(pins)","deepsleep.get_wake_status()","deepsleep.go_to_sleep(seconds)","deepsleep.hw_reset()","deepsleep.pin_wake:","deepsleep.power_on_wake:","deepsleep.set_min_voltage_limit(value)","deepsleep.timer_wake:","describ","devic","device.","dict","disabl","disabled.","ds","ds.enable_pullups('p17')","ds.enable_pullups(['p17',","ds.enable_wake_on_fall('p17')","ds.enable_wake_on_fall(['p17',","ds.get_wake_status()","ds.go_to_sleep(60)","dure","elif","else:","enable_auto_poweroff","enabled.","exampl","example,","example;","extern","fall","featur","features.","feel","free","function","functionality.","github","go","hardwar","i.e.","import","includ","intend","interrupt","librari","libraries.","library,","lipo","list,","method","minimum","more","note","object,","occurs,","p10,","p17,","p18.","pass","period","pic","pin","pins/min","pleas","power","previou","print(\"pin","print(\"pow","print(\"tim","print(wake_s)","protect","pull","pycom","quick","reason","relat","repository.","request","requir","reset","reset\")","return","rise","second","send","set.","set_pullups).","setup","shield","shield.","sleep","sleep.","sourc","specifi","state","statu","target","timer","trigger","turn","under","until","up","up\")","upload","us","user","valu","value.","via","voltag","voltage.","wake","wake,","wake_","wake_s['wake']","wakeup","weekli"],"datasheets/notes.html":["(e.g.","(silver","2","3.3v","3.4v","5.5v.","5v","adapt","against","area","bag","batteri","be","befor","best","between","board","board,","board.","cabl","came","care","carri","caus","check","climates),","cold","compon","connect","connector","damag","destroy","devic","device.","devices.","discharges.","dri","electr","esd","expans","expos","extern","extra","femal","gnd.","gpio","ground","higher","input","insid","irrepar","jst","lead","lot","male","modul","note","order","packaging),","phr","pin","pleas","plug","polar","posit","power","protect","pycom","requir","shock","sourc","source.","static","store","suppli","sure","swapping.","take","them.","tolerant,","us","variant.","via","vin","vin,","vin:","voltag","way"],"pybytes/introduction.html":["accord","accur","air:","alarms.","allow","api","applic","approach.","asset","batteri","boards.","check","command","connect","control","customis","customisable,","dashboard","dashboard;","data","defin","design","devic","device'","devices.","distribut","downgrad","ecosystem","email","empow","entir","environ","exclus","execut","extern","feature;","firmwar","fleet;","freeli","full","gather","geoloc","geolocation.","get","googl","grant","indic","inform","intellig","interest","introduct","iot","keep","key","let'","level,","map","measur","modul","more:","notif","notifications:","nutshell,","offer","optimis","over","perform","position:","pre","pybyt","pybytes?","pycom","receiv","scalabl","sensor","sensors.","seri","services​","set","shell.","sms.","start","started!","statu","status,","stream","termin","terminal:","time","track","up","updat","update.","upgrad","us","version","via","view","visualis","visualisation:","you?","​integr"],"pybytes/getstarted.html":["1:","account.","account:","address","address.","board","click","complet","confirm","connect","creat","email","enter","explor","follow","full","get","go","invent!","it'","link","link.","login.","messag","name,","now","page","password","pybyt","pybytes.","pycom","registr","sent","start","step","time","verif"],"pybytes/connect/":["\"add","(e.g.,","(recommended)","(ssid","/frozen","1.16.x","1:","2:","ad","add","between","built","choos","click","come","connect","credenti","devic","device\"","device.","device;","end","enter","etc.);","explain","firmwar","flash","folder.","give","go","librari","lopy,","manually.","mean","name","network","onward","option","option;","other);","page:","password)","pybyt","pybytes,","pybytes:","pycom","pyscan","pysense,","pytrack,","quickli","section,","select","shield","sipy,","step","two","uniqu","updat","wipy,","wizard","wizard,"],"pybytes/connect/quick.html":["\"add","\"eras","\"forc","(make","1:","2:","add","case","click","computer);","computer.","connect","copi","dashboard!","dashboard.","data","devic","device\"","device'","display","download","explain","extend","file","firmwar","firmware.","flash","here","information.","instal","it'","last","librari","manually.","mark","more","next","now","oper","option","past","port","process:","pybyt","pybytes:","pybytes;","quick","quickli","registration\";","section,","select","serial","set","start","step","step:","sure","system\"","system;","time","token","token.","up","updat","updater.","updater;","us","want"],"pybytes/connect/flash.html":["\"add","\"address\":","\"flash\"","\"micro\",","\"password\":","\"paste_your_serial_port_here\",","\"pybyt","\"python\",","\"sync_folder\":","\"username\":","/flash","/frozen","1.16.x","1:","2.",">","add","atom.","boot","build","button","cable.","case","chang","checkout","click","code","come","comput","connect","credentials.","dashboard!","dashboard.","data","devic","device\"","device'","device,","devicetoken","display","download","e.g.","explain","extract","file","file.","file:","fill","firmwar","flash","flash/pybytes_config.json","folder","folder.","follow","haven't","here","here.","inform","information.","instal","instructions.","it'","last","librari","library\"","library;","manual","manually.","mean","mode.","more","navig","need","next","now","onward","open","over","page","page:","password","past","plugin","plugin,","port","port:","pre","preced","process:","put","pybyt","pybytes.","pybytes:","pybytes;","pycom","pymakr","pymakr.","pymakr.conf","quickli","restart","safe","section,","serial","set","step","step:","tab;","take","time","up","upload","usb","wifi","without","written","{","}"],"pybytes/connect/sigfox/":["[r]","[w].","access","account","account.","add","api","arbitrari","backend,","befor","chose","click","clipboard.","contract","contract.","copi","creat","credenti","custom","devic","devkit","follow","form","form.","go","group","instructions.","link","log","login","manag","more","name,","need","new","ok.","onc","password","past","profil","pybyt","pybytes.","pycom","read","select","set","setup","sigfox","start","type","us","→"],"pybytes/connect/sigfox/devkit.html":["(it","(lopy4,","(on","(which","activ","add","api","api).","associ","automat","backend","backend.","button","callback","check","click","clipboard.","come","component.","comput","configur","connect","connectivity.","contain","contract","contract,","contract.","copi","creat","credenti","custom","default","describ","detail","dev","devic","device),","devices,","devkit","disengag","fipy)","firmwar","first","found","free","go","great","green","group","here.","hold","http","issu","kit","light","lights.","mani","mean","need","note","now","number","on","page","past","post","procedure.","prototyping.","provid","pybyt","pybytes).","pybytes.","pycom","regist","repeat","same","save","second","see","select","sequenc","set","sigfox","sipy,","statu","step","therefor","to:","token","troubleshoot","two","type","type.","types.","updat","updater.","us","want","year","→"],"pybytes/connect/sigfox/custom.html":["(in","(lopy4,","(pybyt","ad","add","api","applic","associ","automat","automatically).","backend","backend.","build","buy","clipboard.","complet","comput","connect","contract","contract.","copi","creat","custom","describ","detail","devic","disengag","fipy)","firmwar","flash","go","here.","itself","newli","number","past","pybyt","pybytes.","pycom","recommend","regist","same","select","sequenc","set","sidebar)","sigfox","sipy,","start","step","talk","to:","token","troubleshoot","type","updat","updater.","us","→"],"pybytes/dashboard.html":["#","(e.g.","(in","(main.py)","1);","10","1:","2:","3:","4:","=","_thread","access","action.","ad","add","added!","adjust","after,","allow","alreadi","also,","applic","argument","arguments:","assum","attribut","bar","be","bottom","button","button.","call","call,","card.","case","chang","chart","chart).","check","checkbox","click","code","code,","commun","connect","corner","creat","create.","created.","cursor","dashboard","dashboard'","dashboard.","data","data.","data;","datatyp","def","defin","define.","denot","devic","device'","device.","device;","display","display.","done","done!","drag","drop","each","edit","enter","exampl","example.","explain","file","finally,","first","float","float32).","follow","function","go","grid","grid.","haven't,","here.","icon","identifi","import","inc(index,","increment","index","inform","infrequ","insert","insid","label","learn","library,","line","main.pi","main.py;","mark","match","mode","modified;","more","name","name,","necessari","new","next","now","now,","number","number,","number;","open","organis","organise.","over","page","paramet","part","particular","persist","persistent,","pin","pin,","point","posit","proce","pybyt","pybytes.","pybytes.send_virtual_pin_valu","pybytes.send_virtual_pin_value(persistent,","pymakr;","rad","receiv","reposit","repres","resiz","right","run","save","save.","scan","second","section,","select","send","sensors_data","set","settings.","signal","sinwav","sleep","step","successfulli","tab","tab.","that,","there!","therefor","thread","three","time","triangl","type","unit","unit).","unit.","up","upload","us","valu","value))","value.","variabl","vector","vector):","virtual","visualis","we'r","widget","widget'","widget.","widgets.","you'v"],"pybytes/integrations/":["applic","cloud","connect","custom","devic","easili","extern","following:","integr","interact","iot","iot:","let","manag","offer","platform","pybyt","secur","servic","services,","way","​aw"],"pybytes/integrations/amazon-iot.html":["(just","allow","allowed),","alphanumer","alway","amazon","attribut","aw","aws,","aws.","binari","bind","broker,","choos","click","client.","consid","consider","consol","correspond","creat","credentials.","custom","dash","data","database.","delet","details.","devic","device'","directli","done,","download","endpoint","everything'","expected,","explor","fill","final","following:","form","futur","future,","generated,","go","group","groups.","insid","integr","integration.","interfac","interface,","iot","it'","key","letter,","local","log","login","messag","mqtt","name","new","notic","on","onc","option","order","otherwis","pass","payload","pleas","possibl","privat","pybyt","pybytes.","ready,","receiv","region","republish","rule.","same","save","secur","see","send","servic","set","sidebar,","specifi","step,","stop","storag","store","summari","test","thing","thing.","things'","topbar.","topic","underscor","up","us","use.","user","want","warning:","way","web","well,","whenev","work","working.","you'll","you'r"],"docnotes/introduction.html":["adher","aim","allow","clariti","confus","design","document","documentation.","eas","featur","however,","introduct","language.","micropython","new","provid","pycom","python","section","specif","straightforward","style","those","typic","understanding.","unusu","us"],"docnotes/syntax.html":["#","'p11'))","(0)","(a","(in","(pin='p12')","(tuple)","(upon","*",",","0))","0,","1,","100000.","13,","4,","5,","=","accept","adc","adc()","adc.channel(*","adc.channel(pin='p16')","allow","alway","analog","anoth","apin","appar","appli","argument","arguments.","assum","astrik","attn=adc.attn_0db)","awar","baudrat","baudrate=100000,","be","befor","below","below,","below.","below:","between","call","called:","case,","certain","channel","class","class,","class.","classes,","color,","constant","constants.","construct","constructor","contain","correct","creat","datetime.","default","denot","describ","descript","design","detail","differ","doc","docs),","document","documentation.","error","exampl","example,","examples/docs)","execut","familiaris","first","follow","format","frequency=5000)","function","gener","i.e.","i2c.init()","i2c.init(i2c.master,","i2c.init(mode,","i2c.master()","id","id.","import","incorrect","input","input.","instead","intent","it,","keyword","keyword,","keyword.","lack","librari","library.","library'","list","machin","method","methods.","micropython","mode","name","name,","name.","notabl","note","noth","object","object).","of.","order","outlin","p16","pass","passed.","pin","pin,","pin='p12')","pin='p16'","pins=('p12',","pins=(sda,","pleas","point","popular","provided.","pwm","pwm(0,","pwm.channel()","pwm.channel(0,","pwm_c","pycom","pycom.rgbled(0xff0000)","pycom.rgbled(color)","pycom.rgbled(color=0xff0000)","python","refer","referenc","regard","reli","requir","return","review","rgbled.","rtc","rtc()","rtc.init((2014,","rtc.init()","rtc.init(datetime)","rtc.init(datetime=(2014,","scl))","section","see","seen","show","specif","specifi","sphinx","standard","state","symbol","syntax","take","thu","to.","tool.","two","typeerror:","unless","upon","us","user","utilis","valid","valu","value.","well","within","without","yourself"],"docnotes/replscript.html":["\"b'3132333435'\"","#","'2'","+","1","1)","=","anyth","arithmet","assign","automat","awar","basic","be","behaviour.","below","both","call","called,","certain","classes/funct","code","consol","console.","demonstr","display","doc","document","exampl","example:","execut","expect","function","given","here...","immedi","import","later","mani","mean","method","micropython","necessarili","need","order","out","output","print","print()","print(1","print(value)","produc","repl","repl.","return","run","save","script","script.","snippet","someth","statement","them.","ubinascii","ubinascii.hexlify(b'12345')","under","us","user","valu","values,","variabl","vs","wish","wrap"],"docnotes/mesh-networks.html":["click","current","development.","document","documentation.","here","informational.","keep","mesh","mind","network","pleas","still","under"],"advance/downgrade.html":["$","(see","...",".tar",".tar(.gz)",".tar.gz","/path/to/firmware/archive.tar.gz","1.0","1.12.0.b0","1.16.0.b1","2.0,","achiev","address","agnost","appear.","archiv","avail","bar","befor","beginning.","behav","below.","between","block","board","board.","button","cli","click","command","commands:","config","connect","devic","device.","downgrad","download","expans","file","fipi","firmwar","flash","follow","frequenc","function","fwtool","g23","gnd","gpi","gui","here).","here:","instead","jumper","latest","latest.","line","local","locat","lopi","lopy4","lora","method","modul","need","now","obtain","onward,","option,","p","point","port","press","previou","prior","procedur","programat","provid","pycom","region","regular","requir","reset","run","screen:","see","set","sipi","specific.","start","t","this.","tick","tool","tool,","two","updat","upgrad","upload","us","usual","v","version","version.","via","wipi","wish"],"advance/cli.html":["$","$pycom","&","(all,","(and","(base64)","(default)","(default:","(lpmac,","(requir","(x86)\\pycom\\pycom","(you","**environ","...","./pyupgrad",".bin)",".cb",".nv",".ota",".tar(.gz)","/","/dev/cu.bluetooth","/dev/cu.usbmodempy343431","/usr/local/bin.","1.14.3).","1.17.5.b6","14.04","2.0","230400.","2]","3","32","3rd","64","921600.",":","[","[command","[command]","[global","[n/a]","[pytrack]","[usb","[wob]","[wob]]","_stub_","`","abov","access","ad","addit","address","address,","address]","again","allow","alreadi","ambiguity.","area","area.","arguments:","as923","au915]","automat","avail","avoid","b","b,","b]","backup","backup.","backup.cb","backup.nv","backup.ota","base","baudrat","befor","below.","between","binari","bit","block","block,","block:","board","boot","bootloader,","button","c","c,","c:\\program","c]","call","caus","cb","certain","chip_id","circumstances.","cli","cli.","cli.ex","click","code","com","com6","combin","command","command,","command.","commands,","config","config)","configur","configuration.","connect","connection.","contain","content","contents,","contents/resources,","contents]","continu","continuation`","copi","courtesi","crash","d","d,","d]","data","debug","debug`","debuggin","default","detail","details.","devic","device.","doing.","done","each","entir","environ","eras","erase_al","erase_f","erase_region","esp32","espbaud**","espbaud.","espport","espport**","espressif","espressif'","esptool","esptool.","etc.","etc.).","eu868","example:","exit","expans","extra","extract","extrapref","extraprefs]","f","factory,","file","file,","file]","files\\pycom\\pycom","find","firmwar","firmware.","first","flash","flash!","flash,","folder","forc","found","from/to","fs,","fs1,","ftdi","ftdi]","ftdi`","function","fwtool","fwtool.","g23","gener","get/set","github.","global","gnd","h","h,","h]","hang","hardwar","hash","have","help","help`","here","here.","here:","higher","https://docs.pycom.io/chapter/advance/cli.html","id","id,","ignor","imag","import","incom","instal","intend","jumper","know","leav","left","line","linux","list","local","locat","location=20","lora","lora_region","lpwan","lt","mac","maco","macos,","macos:","make","maximum","memori","memory.","messag","method","mode","mode.","modif","modul","module.","more","mqtt","mqtt]","mqttserviceaddress","multipl","name","navig","necessary.","need","network","newer)","noexit","noexit`","non","note","note:","nv","nvs,","nvs:","nwpref","nwprefs]","once,","onto","oper","option","option,","option.","order","ota","ota_0,","otadata,","output","output,","overwritten","p","pac","packag","package,","paramet","parameters.","parameters]","parti","partit","partition,","partition]","partitions,","perform","pic","pic]","pic`","pleas","port","port,","port]","port`","ports.","posit","prefer","press","prevent","previou","previous","products.","program","provid","provided,","pwd","pwd]","pybyt","pybytes_config.json","pycom","pycom.","pysense/pytrack/expans","q","q,","q]","quiet","quiet`","r","r,","r]","read","read/writ","reduc","region","region]","relat","remov","repl.","requir","reset","reset`","restor","right","run","running,","s","save","script","secureboot,","see","sequenti","ser=py343434","serial","set","shield","show","sigfox","smac","special","specif","specifi","speed","speed,","speed]","speed`","ssid","ssid]","storag","storage.","structur","sub","success","such","support","suppress","sure","switch","system","t","tar","tar,","tar[.gz]","tar]","tell","through","token","token]","tool","tool,","ubuntu","uid","uid]","uniqu","updat","update\\","upgrad","upload","us","us915","usag","usage:","used.","user","userid","util","v","v,","v]","variabl","verbos","verbose`","version","via","vid:pid=04d8:f013","view","volatil","wifi","window","windows:","wire","without","wmac","wob","workaround","write","x","x,","x]","{list,chip_id,wmac,smac,sigfox,exit,flash,copy,write,write_remote,wifi,pybytes,cb,nvs,ota,lpwan,erase_fs,erase_all}"],"advance/encryption.html":["#","#):","$idf_path/components/esptool_py/esptool/espefuse.pi","$idf_path/components/esptool_py/esptool/espsecure.pi","$idf_path/components/esptool_py/esptool/esptool.pi","(0x1a0000)","(at","(bi","(either","(flash_encryption_key.bin","(for","(ignor","(max","(partit","(write","/dev/ttyusb0","0x0","0x0,","0x0f","0x0f)","0x1000).","0x10000","0x1a0000).","0x8000","2","3","80m","921600","abs_done_0","achiev","additionally,","address","address,","address:","along","applic","application)","artifact","avail","base","baud","befor","below","binari","binaries:","bit","board=gpi","boot","boot;","bootload","bootloader,","bootloader.bin","build","build/gpy/release/bootloader/bootload","build/gpy/release/gpy.bin_enc_0x10000","build/gpy/release/lib/partitions.bin_enc","burn","burn_efus","burn_key","burnt","chain","chip","clean","code","code.","command","command:","commands:","compil","complet","configur","default","detail","detect","digest","digest.bin","digest.bin_enc","dio","directori","done","download","efus","efuse,","efuses.","enabl","encrypt","encrypt_key=flash_encryption_key.bin","encrypted,","encrypted.","encrypted;","encryption)","esp32","esp32,","even","extract_public_key","factori","find","firmwar","firmware,","firmware.","firstli","flag;","flash","flash:","flash_crypt_cnt","flash_crypt_config","flash_encrypt","flash_encryption_key.bin","flash_freq","flash_mod","flash_siz","folder","follow","found","gener","generate_flash_encryption_key","generate_signing_key","generated:","gpy.bin_enc_0x10000","gpy.bin_enc_0x1a0000","here,","here.","hint:","image.","instead","instruct","interface,","irrevers","it'","it.","key","key,","key.bin","key.bin)","key.bin,","keyfil","keys,","level","line","locat","main","make","makefil","manual","mechan","method","micropython","more","more,","need","never","next","no_reset","note:","obtain","onc","open","oper","option","option;","or,","order","ota","ota_0","other","paramet","partit","physic","port","pre","prerequisit","process,","protected)","pycom.ota_slot()","python","random","randomli","re","read","reflash","rel","repo.","respond","run","same","secur","secure=on","secure_boot","secure_boot_signing_key.pem","secure_key=secure_boot_signing_key.pem","secureboot","set:","setup","signature_verification_key.bin","sourc","source.","specif","start","summari","target=[boot|app]","target=app","target=boot","termin","this,","times.","togeth","too.","tool","transform","updat","updated.","us","usb)","valu","version","ways:","write_flash","written","written,","z"],"documents/certificates.html":["2.0","3.0","board","ce","certif","certificate\"","certificate.pdf)","develop","fcc","fipi","g01","gpi","l01","lopi","modul","oem","red","sipi","w01","wipi"],"documents/license.html":["(c)","(mit)","(the","2013","2015","2017,","3","abov","action","addit","and/or","aris","associ","author","avail","charge,","claim,","conditions:","connect","contract,","copi","copy,","copyright","damag","damien","deal","distribute,","document","event","express","file","file,","fit","follow","free","from,","furnish","george,","gnu","gpl","granted,","herebi","holder","https://www.pycom.io/opensource/licens","implied,","includ","inform","is”,","kind,","later","liability,","liabl","licenc","licens","limit","limited.","merchantability,","merge,","mit","modify,","more","noninfringement.","notic","obtain","other","otherwise,","out","p.","particular","permiss","permit","person","portion","provid","publish,","purpos","pycom","restriction,","right","see","sell","shall","so,","softwar","software,","software.","subject","sublicense,","substanti","suppli","terms.","tort","under","us","use,","v1.0","version","version,","warranti","whether","without","“a","“software”),"]},"length":177},"tokenStore":{"root":{"0":{"0":{"4":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"5":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"docs":{},":":{"0":{"0":{"docs":{},":":{"0":{"0":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"1":{"0":{"0":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},"docs":{}},"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"2":{"0":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},"4":{"docs":{},"d":{"8":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}},":":{"docs":{},"f":{"0":{"1":{"3":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"4":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}},"8":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"9":{"docs":{},":":{"5":{"1":{"docs":{},":":{"4":{"6":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.01904761904761905},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.02},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.032520325203252036},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.010183299389002037},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.012195121951219513},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"1":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}},"2":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"5":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},"9":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"x":{"0":{"0":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"1":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"f":{"docs":{},"f":{"0":{"0":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}}}},"1":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}},"2":{"0":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"3":{"0":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},"]":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},")":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}},"4":{"0":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},"d":{"8":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"docs":{}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}},"5":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"6":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"7":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"8":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"f":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},")":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"1":{"0":{"0":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}}},"docs":{},")":{"docs":{},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}},"8":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"docs":{},"a":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"2":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}},"docs":{}},"8":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"3":{"0":{"0":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"4":{"0":{"0":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"docs":{}},"2":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}}},"docs":{}},"7":{"7":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},"docs":{},"f":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"c":{"docs":{},")":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"f":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"8":{"0":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"docs":{}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}},"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}},"9":{"5":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025}}}},"docs":{}},"docs":{},"e":{"docs":{},"f":{"3":{"7":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"8":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"9":{"8":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"9":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"docs":{}}},"f":{"0":{"1":{"1":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},"2":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},"3":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"4":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"docs":{}},"1":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"8":{"docs":{},"]":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}},"9":{"docs":{},"]":{"docs":{},"]":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}},"docs":{},"f":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}},"d":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025}}}}}},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.022222222222222223}},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},";":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"d":{"docs":{},"b":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.023668639053254437},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01092896174863388}}},"%":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"}":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"1":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}},"*":{"1":{"0":{"0":{"docs":{},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}}},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"u":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}},"%":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"h":{"docs":{},"z":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"u":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},":":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"m":{"docs":{},"a":{"docs":{},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}},"2":{"4":{"docs":{},"]":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}},"docs":{},".":{"4":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"docs":{}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},":":{"3":{"0":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}},"docs":{}},"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"h":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"m":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}},"a":{"docs":{},".":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889}}}}},",":{"0":{"0":{"0":{"docs":{},"u":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"docs":{}},"docs":{}},"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"%":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"u":{"docs":{},"a":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}},".":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},"k":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}},"1":{"2":{"0":{"docs":{},".":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}},"docs":{}},"5":{"2":{"0":{"0":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"d":{"docs":{},"b":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"2":{"0":{"docs":{},"m":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"2":{"docs":{},"h":{"docs":{},"z":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}},"3":{"4":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},"5":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"8":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"d":{"docs":{},"b":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"3":{"6":{"0":{"4":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}},"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}},"4":{"6":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},":":{"2":{"3":{"docs":{},":":{"5":{"8":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},".":{"0":{"4":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{}},"docs":{}}},"5":{"1":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"6":{"3":{"8":{"4":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"docs":{}},"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}},"\"":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"8":{"0":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{},"d":{"docs":{},"b":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}},"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"1":{"docs":{},".":{"1":{"4":{"4":{"docs":{},":":{"8":{"0":{"0":{"0":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"4":{"docs":{},".":{"1":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}},")":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"7":{"0":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"docs":{}},"docs":{},".":{"7":{"docs":{},"µ":{"docs":{},"a":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}}},"docs":{}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.019851116625310174},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.045454545454545456}},":":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}},".":{"0":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},".":{"0":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"1":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"2":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"9":{"9":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789}}},"docs":{}},"docs":{},"x":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"1":{"2":{"docs":{},".":{"0":{"docs":{},".":{"docs":{},"b":{"0":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}},"docs":{}}}},"docs":{}}},"4":{"docs":{},".":{"3":{"docs":{},")":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"docs":{}}},"6":{"docs":{},".":{"0":{"docs":{},".":{"docs":{},"b":{"1":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602}}},"docs":{}}}},"docs":{},"x":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}},"7":{"docs":{},".":{"0":{"docs":{},".":{"docs":{},"b":{"1":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},"docs":{}}}},"5":{"docs":{},".":{"docs":{},"b":{"6":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{}}}},"docs":{}}},"docs":{},"v":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},",":{"0":{"docs":{},",":{"0":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}},"docs":{}}},"2":{"5":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"docs":{},".":{"5":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"docs":{}}},"4":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"5":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}},".":{"2":{"5":{"4":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"docs":{}},"docs":{}},"docs":{}}},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01953125},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"]":{"docs":{},")":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}}}},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"2":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}},"m":{"docs":{},"g":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"5":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"9":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"m":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}},"1":{"0":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"3":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"4":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"5":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"6":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"7":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"8":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"docs":{}},"4":{"8":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"docs":{}},"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"*":{"1":{"0":{"0":{"docs":{},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{}},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}},"1":{"docs":{},";":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"2":{"4":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}},"docs":{}},"3":{"0":{"4":{"0":{"0":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"4":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"5":{"0":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}},"4":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"5":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"6":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"7":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}},"8":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"9":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.011278195488721804},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.02564102564102564},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},":":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},".":{"0":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":5.004385964912281},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":3.346153846153846},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.03816793893129771}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}},"4":{"docs":{},"g":{"docs":{},"h":{"docs":{},"z":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}}}},"5":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"7":{"docs":{},":":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"x":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"u":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}}},"g":{"docs":{},"/":{"3":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}}}}}}},"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"m":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"a":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"*":{"docs":{},"*":{"docs":{},"e":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}},"3":{"0":{"0":{"docs":{},"k":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"6":{"0":{"7":{"6":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"%":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"1":{"2":{"5":{"docs":{},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}}},"docs":{}},"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},")":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"2":{"7":{"6":{"8":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{}},"9":{"docs":{},"a":{"docs":{},"l":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"7":{"6":{"8":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"docs":{}},"docs":{}},"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},"\"":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"6":{"6":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"docs":{}},"7":{"5":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"7":{"8":{"1":{"docs":{},".":{"docs":{},"d":{"docs":{},"u":{"docs":{},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"'":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"4":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}},"6":{"3":{"8":{"docs":{},".":{"docs":{},"d":{"docs":{},"u":{"docs":{},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},".":{"0":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":5.006896551724138},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":3.3400900900900896},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555}}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}}}}}}}}},"2":{"7":{"6":{"8":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"docs":{}},"docs":{}},"docs":{}},"3":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872}},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"4":{"docs":{},"v":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"5":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"v":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"6":{"docs":{},".":{"5":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}},"x":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},":":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"v":{"3":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}},")":{"docs":{},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}},"docs":{},"p":{"docs":{},"p":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"d":{"docs":{},".":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}},"g":{"docs":{},"p":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"r":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}},"4":{"0":{"9":{"6":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},"docs":{}},"docs":{}},"3":{"3":{"docs":{},"m":{"docs":{},"h":{"docs":{},"z":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}}}}}},"docs":{}},"4":{"3":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},"[":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"docs":{}}}},"docs":{}},"5":{"0":{"docs":{},"m":{"docs":{},"a":{"docs":{},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}},"docs":{}},"8":{"6":{"5":{"6":{"docs":{},"c":{"6":{"docs":{},"c":{"6":{"docs":{},"f":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}},")":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":5.002976190476191},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":5.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},":":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"m":{"docs":{},"b":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862}},".":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}},"s":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}},"/":{"5":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}},"docs":{}},".":{"2":{"docs":{},".":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}},"docs":{}},"k":{"docs":{},"i":{"docs":{},"b":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"5":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"m":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{},"u":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},":":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"docs":{},"%":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"1":{"2":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},"k":{"docs":{},"b":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}}},"docs":{}},"4":{"8":{"5":{"4":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"docs":{}},"docs":{}},"docs":{}},"9":{"9":{"6":{"9":{"3":{"8":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}},"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.016216216216216217},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"docs":{}}},"docs":{}}},"1":{"docs":{},".":{"1":{"docs":{},".":{"0":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577}}},"docs":{}}},"docs":{}}},"5":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"v":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349}},".":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"docs":{}},"t":{"docs":{},"h":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}}},"v":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"6":{"0":{"0":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"4":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},")":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"\"":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"5":{"5":{"3":{"5":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"docs":{}},"docs":{}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"d":{"docs":{},"b":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}},"7":{"0":{"docs":{},"b":{"3":{"docs":{},"d":{"5":{"4":{"9":{"9":{"5":{"8":{"5":{"docs":{},"f":{"docs":{},"c":{"docs":{},"a":{"1":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"1":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"8":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}},"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":2.5076923076923077},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},",":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},".":{"8":{"docs":{},".":{"0":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"docs":{}}},"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"u":{"docs":{},"a":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},"8":{"0":{"0":{"0":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{}},"8":{"0":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},"docs":{}},"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}},"%":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},"[":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"docs":{}}},"m":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"1":{"9":{"2":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}}},"docs":{}},"docs":{}},"4":{"4":{"1":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},"[":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"docs":{}}}},"docs":{}},"9":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},"docs":{}},"6":{"3":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"8":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},"m":{"docs":{},"h":{"docs":{},"z":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"/":{"9":{"1":{"5":{"docs":{},"m":{"docs":{},"h":{"docs":{},"z":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"docs":{}},"7":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"8":{"8":{"3":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"docs":{}},"docs":{}},"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}},"m":{"docs":{},"b":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}},".":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}},"/":{"1":{"0":{"docs":{},"/":{"docs":{},"+":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}},",":{"docs":{"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}}},"docs":{}},"docs":{}},"'":{"docs":{},")":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}}},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"8":{"docs":{},".":{"8":{"docs":{},".":{"8":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"docs":{}}},"docs":{}}},"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"]":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"9":{"0":{"2":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},".":{"0":{"docs":{},".":{"3":{"9":{"docs":{},".":{"1":{"docs":{},")":{"docs":{},"]":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"1":{"2":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}},"5":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},"m":{"docs":{},"h":{"docs":{},"z":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"docs":{}},"2":{"1":{"6":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"docs":{}},"6":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"9":{"docs":{},"%":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},")":{"docs":{},":":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"1":{"docs":{},".":{"0":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}},"docs":{}}},"docs":{},"&":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.017142857142857144},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},"a":{"2":{"0":{"docs":{},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}},"docs":{}},"docs":{},"p":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.012962962962962963},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"i":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":5.090909090909091},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":3.3361986628462272},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.0449438202247191},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082}},".":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"n":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}},")":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},".":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"s":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},",":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},".":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}},":":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"u":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}}}},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077}}}}},"l":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},"i":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"c":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.017191977077363897},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.03409090909090909},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.014184397163120567},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.034482758620689655},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"_":{"docs":{},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}}},"s":{"docs":{},"w":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},")":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"i":{"docs":{},"m":{"docs":{},"g":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}},"a":{"docs":{},"r":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"m":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.010126582278481013}}},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.03333333333333333},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0273972602739726},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.027586206896551724},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.026490066225165563},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0547945205479452},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.03333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.05263157894736842},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.05263157894736842},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.02564102564102564},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"_":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"/":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}}}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}},"c":{"docs":{},"c":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.023809523809523808},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.02631578947368421},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.022339027595269383},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.02},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266}}}}},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0106951871657754},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},":":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}},"p":{"docs":{},"t":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.013779527559055118},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00718954248366013},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01366120218579235}},"e":{"docs":{},"d":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.016736401673640166},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955}}},":":{"docs":{"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}}}}},"r":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}}},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}}}}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"u":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"2":{"0":{"0":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}}}}}},"u":{"docs":{},"r":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.024615384615384615}}}}}},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806}},"i":{"docs":{},"v":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},";":{"docs":{"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421}}},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"y":{"docs":{},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},"o":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.00975609756097561}}}}}},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.01240694789081886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{"products.html":{"ref":"products.html","tf":0.04},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.019830028328611898},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.026785714285714284},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.02040816326530612},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.021686746987951807},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.015873015873015872},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"=":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},")":{"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}},"s":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":5.020080321285141},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}}}}}},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}},"d":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.02459016393442623},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"v":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01953125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.01653944020356234},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}},"r":{"docs":{},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}}}}}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.02857142857142857}},"'":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"d":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"pybytes/connect/":{"ref":"pybytes/connect/","tf":3.3745704467353947},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":2.5096153846153846},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":3.3445692883895126},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.021505376344086023},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.014970059880239521}},"(":{"1":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"docs":{}}}}}}}},"r":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.017605633802816902},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.037267080745341616},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02022058823529412},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.02631578947368421},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.018726591760299626},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.014962593516209476}},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02022058823529412},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}},"/":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"\"":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"=":{"0":{"docs":{},"x":{"2":{"3":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"docs":{}},"docs":{}}},"docs":{},"i":{"2":{"docs":{},"c":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}}}}},"docs":{}}}}}}}}}}},"docs":{}}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}},"e":{"docs":{},"=":{"8":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}}},"docs":{}}}}}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.0625},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}},"!":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"c":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":10.080357142857142},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":15.060240963855422},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},"(":{"0":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}},"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},".":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"=":{"docs":{},"'":{"docs":{},"p":{"1":{"3":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}},"6":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"docs":{}},"docs":{}}}}}}},"*":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}}}},"v":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"(":{"1":{"1":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"v":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"2":{"2":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}},"docs":{}},"docs":{}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"n":{"docs":{},"_":{"0":{"docs":{},"d":{"docs":{},"b":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}}}}},"1":{"1":{"docs":{},"d":{"docs":{},"b":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}}}},"docs":{}},"2":{"docs":{},"_":{"5":{"docs":{},"d":{"docs":{},"b":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}}}}},"docs":{}}},"6":{"docs":{},"d":{"docs":{},"b":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}}}}},"docs":{}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}},"_":{"docs":{},"c":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856}},"(":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}},".":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":5.004016064257028}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},"a":{"docs":{},"y":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.00998003992015968},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":10.076923076923077}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}}}}}}}}}}}}}}}}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077}}}}},"i":{"docs":{},"v":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"e":{"docs":{},".":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}}},"e":{"docs":{},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"a":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},".":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}}},"d":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}}}},"c":{"docs":{},"h":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"i":{"docs":{},"v":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602}},"e":{"docs":{},".":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}},"g":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.009398496240601503},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.015772870662460567},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.018461538461538463},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.04644808743169399}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.01342756183745583}}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},",":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"s":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889}}}}}},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}},"l":{"docs":{},"i":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}}},"s":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549}}}},"v":{"docs":{},"e":{"docs":{},".":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}}},"a":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.012944983818770227},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.025787965616045846},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}},"c":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.013377926421404682},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}},".":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}}}}}}},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"e":{"docs":{},"x":{"docs":{},"!":{"docs":{},"\"":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.013477088948787063}}}}},"u":{"docs":{},"m":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"=":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}}}},"s":{"docs":{},"_":{"docs":{},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"1":{"docs":{},"x":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"_":{"docs":{},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"docs":{}}}}}}}}}}}}},"4":{"8":{"docs":{},"x":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"docs":{},"x":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"8":{"docs":{},"x":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"9":{"6":{"docs":{},"x":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"1":{"0":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"3":{"0":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"4":{"0":{"0":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"docs":{}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"1":{"0":{"0":{"0":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}}}}}}},"o":{"docs":{},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"a":{"docs":{},"r":{"docs":{},"m":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0220125786163522},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},")":{"docs":{},":":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"s":{"docs":{},".":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}}}}},"s":{"9":{"2":{"3":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{}},"docs":{}},"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}}},"g":{"docs":{},"n":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"e":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176}},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"b":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"w":{"docs":{},"a":{"docs":{},"v":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"u":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"i":{"docs":{},"a":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}},"k":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"r":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"k":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.007339449541284404},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.015189873417721518},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":10.024647887323944}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},"/":{"docs":{},"v":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"n":{"docs":{},"u":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338}}},"d":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},"n":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"=":{"docs":{},"a":{"docs":{},"d":{"docs":{},"c":{"docs":{},".":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"n":{"docs":{},"_":{"0":{"docs":{},"d":{"docs":{},"b":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"1":{"1":{"docs":{},"d":{"docs":{},"b":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"s":{"docs":{},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}},"&":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}},"u":{"9":{"1":{"5":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{}},"docs":{}},"docs":{},"t":{"docs":{},"o":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"m":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.04878048780487805},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},":":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},")":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}}}}}}}}}}},"h":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.015968063872255488},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}},"=":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"_":{"docs":{},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"p":{"docs":{},"a":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"docs":{}}}}}}}}}}}}}}}}},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"p":{"docs":{},"a":{"2":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"'":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"p":{"docs":{},"y":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"'":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}}}},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}},")":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}},"docs":{}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}}},"o":{"docs":{},"r":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"e":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}}},"b":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},"g":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"a":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":5.012422360248447}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02857142857142857}},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}}}}},"w":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":10.013513513513514},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.062111801242236024}},"a":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"e":{"docs":{},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}},"y":{"docs":{"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456}}},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"t":{"docs":{},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"b":{"0":{"0":{"1":{"2":{"3":{"4":{"docs":{},"\"":{"docs":{},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"o":{"docs":{},"v":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"p":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":5.021857923497268},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},"_":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"_":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"docs":{}}}}}}}},"i":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"l":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"c":{"1":{"docs":{},"d":{"docs":{},"e":{"4":{"5":{"docs":{},"b":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}},"docs":{}},"docs":{}}}},"docs":{}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}},"n":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655}}}}}}},"i":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},":":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}},"m":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.05714285714285714}}}},"x":{"docs":{},"i":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223}}}}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},":":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"e":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":10.019762845849803},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"s":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}}}}}}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},"c":{"docs":{},":":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}},"f":{"docs":{},"b":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},":":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}},"r":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}},"t":{"docs":{},"r":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},":":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}},"e":{"docs":{},"c":{"docs":{},"b":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},":":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"g":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"1":{"2":{"8":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},":":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"docs":{}},"docs":{}},"8":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"docs":{}}}}}}}}}}}}},"b":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"e":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.0625},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.014545454545454545},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}},"n":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}},":":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"n":{"docs":{},"g":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"e":{"docs":{},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.006535947712418301},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.030303030303030304},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},"a":{"docs":{},"t":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},"r":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}},")":{"docs":{},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},".":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},":":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},".":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}}},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.015037593984962405},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.01891891891891892},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.012468827930174564}},"/":{"docs":{},"g":{"docs":{},"p":{"docs":{},"y":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"/":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"p":{"docs":{},"y":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"_":{"0":{"docs":{},"x":{"1":{"0":{"0":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},"i":{"docs":{},"n":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":10.035294117647059}}}}}}},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0169971671388102},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.017857142857142856},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.01749271137026239},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.014457831325301205},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.01904761904761905},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.010638297872340425},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.023952095808383235},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},")":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}},".":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"s":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"m":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"y":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},"g":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"f":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.013157894736842105},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}}},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622}}},"e":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},":":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}}},"r":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"_":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"s":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}}}}},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.05263157894736842},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.05263157894736842},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.038461538461538464},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.031746031746031744},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"y":{"docs":{},",":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}}}}},"s":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"c":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},")":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}},"e":{"6":{"4":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.030303030303030304}}},"docs":{}},"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":2.53125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":2.525}}}}}}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409}},"s":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098}},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"b":{"docs":{},"w":{"docs":{},"_":{"1":{"2":{"5":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}},"=":{"2":{"0":{"docs":{},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}},"docs":{}},"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"g":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"c":{"docs":{},"k":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.016736401673640166},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},")":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}},"u":{"docs":{},"p":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/cli.html":{"ref":"advance/cli.html","tf":0.009893992932862191}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"c":{"docs":{},"b":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"n":{"docs":{},"v":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},",":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"r":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825}}}}}}},"e":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"u":{"docs":{},"d":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"=":{"1":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"9":{"6":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}},"g":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":10.0390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":10.024173027989821},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429}},",":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"1":{"2":{"8":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"r":{"docs":{},"v":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"docs":{}},"6":{"docs":{},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"docs":{}},"3":{"2":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"r":{"docs":{},"v":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"docs":{}},"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}},"t":{"1":{"6":{"docs":{},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"docs":{}},"docs":{},"x":{"docs":{},"_":{"docs":{},"p":{"docs":{},"w":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"[":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}},"'":{"1":{"1":{"2":{"2":{"3":{"3":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"f":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"_":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"docs":{}}}}}}},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"_":{"docs":{},"n":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"docs":{}},"2":{"0":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}},"docs":{}},"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"_":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"r":{"docs":{},"s":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"1":{"2":{"3":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"docs":{}},"docs":{}},"docs":{}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"=":{"docs":{},"b":{"docs":{},"'":{"1":{"2":{"3":{"4":{"5":{"6":{"7":{"8":{"9":{"0":{"1":{"2":{"3":{"4":{"5":{"6":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"*":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"'":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}}}},"x":{"docs":{},"t":{"docs":{},"_":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.02112676056338028},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.011976047904191617},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.019704433497536946},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.02185792349726776},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.013108614232209739},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},":":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}}}}},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.02027027027027027},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}},"c":{"docs":{},"k":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"e":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.02734375},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.010178117048346057},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.03773584905660377},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}},"y":{"docs":{},"n":{"docs":{},"k":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}}}}}},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"products.html":{"ref":"products.html","tf":0.03333333333333333},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.019830028328611898},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.020833333333333332},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.02040816326530612},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0220125786163522},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.021686746987951807},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.022222222222222223},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.027777777777777776},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.011009174311926606},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.020253164556962026},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.017605633802816902},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.02304964539007092},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.03333333333333333},"datasheets/boards/":{"ref":"datasheets/boards/","tf":3.444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":3.3806306306306304},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.05263157894736842},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.05263157894736842},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":3.4358974358974357},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}},"s":{"docs":{},",":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}},".":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602}}},"/":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"'":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"=":{"docs":{},"g":{"docs":{},"p":{"docs":{},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.017456359102244388}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"h":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},".":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}},"o":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":5.024305555555555},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.019438444924406047},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.012468827930174564}},"s":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444}}}},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},"p":{"docs":{},"i":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}},"\"":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.010638297872340425},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0199501246882793}},"e":{"docs":{},"r":{"0":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"*":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"2":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"*":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},";":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"k":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},"x":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}},"!":{"docs":{"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},".":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}},"n":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}},"a":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}},"z":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223}}}}}},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}},"w":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}},"i":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"w":{"docs":{},"l":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},"[":{"6":{"docs":{},":":{"docs":{},"]":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},"docs":{},":":{"6":{"docs":{},"]":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"5":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.07575757575757576},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.017391304347826087},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0125},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.0379746835443038},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.026490066225165563},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.009198423127463863},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.028391167192429023},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.03225806451612903},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"s":{"docs":{},"=":{"1":{"2":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},"docs":{}},"8":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}},"docs":{}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},":":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}},"/":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}},"g":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.017964071856287425},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0125},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.019851116625310174},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.008888888888888889},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.02631578947368421},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.02702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.021956087824351298},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.019867549668874173},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.02631578947368421},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.014962593516209476},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.04878048780487805},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.045454545454545456},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.018726591760299626},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"s":{"docs":{},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"(":{"docs":{},"[":{"0":{"docs":{},"x":{"0":{"1":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{}},"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}},"docs":{}},"docs":{}}},"docs":{}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},".":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"(":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"8":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}},"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}}}}},"t":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"_":{"docs":{},"o":{"docs":{},".":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}},"h":{"1":{"7":{"5":{"0":{"docs":{},"f":{"docs":{},"v":{"docs":{},"i":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.023809523809523808}},".":{"docs":{},"b":{"docs":{},"h":{"1":{"7":{"5":{"0":{"docs":{},"f":{"docs":{},"v":{"docs":{},"i":{"docs":{},"(":{"docs":{},"i":{"2":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}}}}},"docs":{}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"p":{"docs":{},"y":{"docs":{},".":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"%":{"docs":{},"d":{"docs":{},"s":{"docs":{},".":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.017369727047146403}}},"'":{"4":{"5":{"6":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}},"docs":{}},"docs":{}},"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{},":":{"docs":{"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"'":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}}}}}}}}}}},"w":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}},"d":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"f":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"p":{"docs":{},"o":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}}},"d":{"0":{"docs":{},"d":{"docs":{},"c":{"7":{"0":{"8":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}},"v":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516}},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.04819277108433735},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.017045454545454544},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/":{"ref":"datasheets/development/","tf":5.111111111111111},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}}}}}}}}}},"u":{"docs":{},"i":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.024844720496894408},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.034722222222222224},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.012844036697247707},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.01680672268907563},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.021052631578947368},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.017361111111111112},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":5.105263157894737},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.058577405857740586},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.029069767441860465},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.04011461318051576},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.05397727272727273},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.02112676056338028},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.01567398119122257},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.013623978201634877},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.024844720496894408},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.0625},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.02127659574468085},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.02564102564102564},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/":{"ref":"tutorials/all/","tf":3.4999999999999996},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.01675977653631285},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.009216589861751152},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0390625},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.015202702702702704},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.02},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.01920768307322929},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.03571428571428571},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.011450381679389313},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.03773584905660377},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.014962593516209476},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.011461318051575931},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.031746031746031744},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176},"pybytes/connect/":{"ref":"pybytes/connect/","tf":3.4570446735395186},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.0673076923076923},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.061855670103092786},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":3.3782771535580522},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.08064516129032258},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.11475409836065574},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":3.3512974051896203},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.07142857142857142},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.031055900621118012},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}},"e":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.03614457831325301},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"s":{"docs":{},":":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}}}},"'":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.021052631578947368},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.022058823529411766},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.020618556701030927},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},"!":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},":":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.014285714285714285},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.009925558312655087}}},")":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}}},"\"":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},";":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}},"k":{"docs":{},"i":{"docs":{},"t":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":5.016129032258065}}}}}},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}}}}}}},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512}}}}},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"c":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}}}}}}},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}},"e":{"docs":{},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.008888888888888889},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.02631578947368421},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.026200873362445413},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.02666666666666667},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":3.4705882352941173},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":3.364851957975167}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915}},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}},"o":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"w":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},":":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},":":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},":":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.008595988538681949}}}}}}}}}}},"f":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0225},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.015789473684210527},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.018633540372670808},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.011278195488721804},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.013972055888223553},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"advance/cli.html":{"ref":"advance/cli.html","tf":0.005653710247349823},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}},"i":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.00788436268068331},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.017964071856287425}},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"r":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}}},"b":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.03424657534246575},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"t":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"r":{"docs":{},"o":{"docs":{},"y":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.041666666666666664},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"t":{"docs":{},"h":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"e":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}},"e":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"t":{"docs":{},"a":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}},"i":{"docs":{},"v":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}},"m":{"docs":{},"o":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"b":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"u":{"docs":{},"g":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}}},"o":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"c":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.11428571428571428},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}}},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}}}}}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},")":{"docs":{},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"u":{"docs":{},"b":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"l":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}}}}},"n":{"docs":{},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},"!":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"'":{"docs":{},"t":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"'":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"w":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.024844720496894408},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.020833333333333332},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.03076923076923077},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.02577319587628866},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.00997506234413965}},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"_":{"docs":{},"h":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":5.019607843137255}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}},"'":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"z":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334}},"(":{"docs":{},"\"":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},":":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"l":{"docs":{},"i":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}}},"y":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.018633540372670808},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}},"y":{"docs":{},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.03111111111111111}}},")":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"f":{"docs":{},"f":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}}}}},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"g":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"o":{"docs":{},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"e":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015}}}}}}}}}},"v":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"(":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},",":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}}}}},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"y":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}},"a":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}},"v":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},"o":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"r":{"docs":{},"i":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"v":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889}},"r":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":10.06832298136646},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.014184397163120567},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":2.576923076923077},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":5.0025},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.09523809523809523},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.030612244897959183}},"s":{"docs":{},";":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},":":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},".":{"docs":{"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"'":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},",":{"docs":{},"'":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"'":{"docs":{},":":{"docs":{},"'":{"3":{"2":{"3":{"6":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"'":{"docs":{},":":{"docs":{},"'":{"1":{"3":{"0":{"1":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"n":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"o":{"docs":{},"p":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385}}}}}}}},"a":{"docs":{},"w":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}}},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}},"g":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}},"=":{"0":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"_":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"=":{"6":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"=":{"5":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}}},"a":{"docs":{},"m":{"docs":{},"a":{"docs":{},"g":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"t":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"docs":{},"a":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.022653721682847898},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.02734375},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.014285714285714285},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.012004801920768308},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.013257575757575758},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.028368794326241134},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.03940886699507389},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.04371584699453552},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.013513513513513514},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.00998003992015968},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.018329938900203666},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.017811704834605598},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.03125},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00718954248366013},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.012903225806451613},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.01079913606911447},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.07575757575757576},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.020599250936329586},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.08695652173913043},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.04411764705882353},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":3.3512974051896203},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.020689655172413793},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.024},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.07894736842105263},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.07894736842105263},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.030612244897959183},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.038461538461538464}},"s":{"docs":{},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112}}}}}}}}},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"[":{"6":{"docs":{},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"7":{"docs":{},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{},"i":{"docs":{},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},".":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"=":{"docs":{},"b":{"docs":{},"'":{"1":{"2":{"3":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"docs":{}},"docs":{}},"docs":{}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"[":{"0":{"docs":{},"x":{"0":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}},"docs":{}},"docs":{}}},"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"e":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.01775147928994083}},"e":{"docs":{},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"/":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}},"y":{"docs":{},"s":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}},"c":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":10.071428571428571}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"docs":{}}},"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}}}}}}}}},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"1":{"0":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"w":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}},"s":{"docs":{},"h":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617}},";":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"!":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},".":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}},"'":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}}}},"c":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666}}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}},"a":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.022727272727272728},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.03054989816700611},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"[":{"docs":{},"i":{"docs":{},"]":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}}}}},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}},"e":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}},"a":{"docs":{},"l":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"e":{"docs":{},"x":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"_":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}},"e":{"docs":{},"=":{"0":{"docs":{},".":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018}}}},"docs":{}}},"docs":{}}}}}}}}},"i":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.032520325203252036},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"'":{"docs":{},",":{"docs":{},"'":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"0":{"0":{"5":{"4":{"docs":{},"e":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"f":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0673758865248227},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},"s":{"1":{"8":{"docs":{},"b":{"2":{"0":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"docs":{}},"docs":{}},"x":{"2":{"0":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}},"(":{"docs":{},"o":{"docs":{},"w":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"1":{"7":{"docs":{},"'":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"docs":{}},"docs":{}}},"[":{"docs":{},"'":{"docs":{},"p":{"1":{"7":{"docs":{},"'":{"docs":{},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"1":{"7":{"docs":{},"'":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"docs":{}},"docs":{}}},"[":{"docs":{},"'":{"docs":{},"p":{"1":{"7":{"docs":{},"'":{"docs":{},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}},"o":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"6":{"0":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"h":{"docs":{},"c":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}},"t":{"1":{"1":{"docs":{},"/":{"docs":{},"d":{"docs":{},"h":{"docs":{},"t":{"2":{"2":{"docs":{},"/":{"docs":{},"a":{"docs":{},"m":{"2":{"3":{"0":{"2":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}},"b":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"m":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"e":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":5.009708737864078},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.041666666666666664},"tutorials/all/":{"ref":"tutorials/all/","tf":3.4999999999999996},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.009603841536614645},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364},"tutorials/lora/":{"ref":"tutorials/lora/","tf":5.009615384615385},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":5.004464285714286},"tutorials/lte/":{"ref":"tutorials/lte/","tf":5.016666666666667},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":5.037037037037037},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":5.037037037037037},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":5.0375},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01912568306010929},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"s":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},":":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.01079913606911447},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},";":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"l":{"docs":{},"i":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"y":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0169971671388102},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.017857142857142856},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.01749271137026239},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.01927710843373494},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.01904761904761905},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.014084507042253521},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/boards/":{"ref":"datasheets/boards/","tf":3.4999999999999996},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":3.3738738738738734},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":3.423076923076923},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.031746031746031744},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}},"d":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"l":{"docs":{},"i":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}}}},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.016181229773462782},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"i":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},".":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}},"s":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.022922636103151862},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.07142857142857142}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}},"n":{"docs":{},"s":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.02054794520547945}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}}}}},"d":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"c":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"_":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"s":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"c":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"p":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.016666666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},";":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}},".":{"docs":{},".":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0176678445229682}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"s":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}},"s":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}},"y":{"docs":{},".":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}}},"i":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},"r":{"docs":{},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}},"l":{"docs":{},"i":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}}}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"p":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.01152073732718894}}}},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.024096385542168676},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.013368983957219251},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.01511879049676026},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}},"e":{"docs":{},".":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}},"d":{"docs":{},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"_":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"(":{"docs":{},"i":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"l":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}},"s":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}},"i":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}},"r":{"docs":{},"i":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.03162055335968379},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023},"advance/encryption.html":{"ref":"advance/encryption.html","tf":5.032418952618454}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"=":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},";":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}},"o":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.045454545454545456},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"d":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.012004801920768308},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"=":{"docs":{},"\"":{"docs":{},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208}},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}},".":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}}}}},"d":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415}},"g":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},"e":{"docs":{},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}}}}},"i":{"docs":{},"t":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"o":{"docs":{},"r":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}},"s":{"docs":{},",":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05}}}},"'":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.00984251968503937},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.03428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00522875816993464},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.022900763358778626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.022900763358778626}},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},".":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},":":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.011363636363636364},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.01445466491458607},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.046153846153846156},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},":":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},"v":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"c":{"docs":{},"t":{"docs":{},"r":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872}},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}},"i":{"docs":{},"f":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"s":{"docs":{},"e":{"docs":{},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}}}}}}},"t":{"docs":{},"c":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},")":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},";":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}}}},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},".":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},"i":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},"o":{"docs":{},"w":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176}}}}},"u":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.045454545454545456}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}}}}},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},"o":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}}},"u":{"8":{"6":{"8":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"i":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.022727272727272728}},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"a":{"docs":{},"t":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}},"a":{"docs":{},"s":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}},"f":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}}}}}},"p":{"3":{"2":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"'":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}},")":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"docs":{}},"docs":{},"b":{"docs":{},"a":{"docs":{},"u":{"docs":{},"d":{"docs":{},"*":{"docs":{},"*":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"*":{"docs":{},"*":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"'":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"t":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}}}}},"d":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}}},"f":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},".":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"e":{"docs":{},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"s":{"docs":{},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},"o":{"docs":{},"f":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"p":{"docs":{},"o":{"docs":{},"c":{"docs":{},"h":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},":":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"f":{"0":{"1":{"4":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"docs":{}},"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"a":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"i":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"v":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}}}}}},"i":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}},".":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"u":{"docs":{},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}},"s":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"h":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}}},"r":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},"c":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},"o":{"docs":{},"r":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504}},"i":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"y":{"docs":{},".":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"'":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},"i":{"docs":{},"l":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"l":{"docs":{},"s":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"e":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},".":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"l":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.011461318051575931}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}}}}},"t":{"1":{"6":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}},"/":{"3":{"2":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}},"docs":{}},"docs":{}}},"docs":{}},"3":{"2":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"docs":{}},"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.05263157894736842},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},":":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"/":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}}}}}}}}}}}}}}}}},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}},";":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"d":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.06086956521739131},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}},"w":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"d":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}},"b":{"docs":{},"r":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"l":{"docs":{},"i":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"q":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"y":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"=":{"5":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"6":{"8":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"9":{"1":{"2":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},")":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"t":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}}}}}}},"o":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"z":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"(":{"docs":{},"[":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}},"m":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.011811023622047244}},".":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"=":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}},"i":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"n":{"docs":{},"d":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"a":{"docs":{},"l":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}}}}},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"t":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}},"p":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":10.043373493975903},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":10.066225165562914},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.05343511450381679}}},"y":{"docs":{},",":{"docs":{"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},".":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555}}},":":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},")":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}},"r":{"docs":{},"m":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.024096385542168676},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":5.041666666666667},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.029288702928870293},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.010126582278481013},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":5.0177304964539005},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":3.3635709143268535},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.029411764705882353},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.07692307692307693},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.03278688524590164},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":5.071895424836601},"advance/cli.html":{"ref":"advance/cli.html","tf":0.009187279151943463},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"e":{"docs":{},",":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},";":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}},"_":{"1":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}},"1":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}},"l":{"docs":{},"i":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525}}}},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":3.340672782874617},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.00788436268068331},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"l":{"docs":{},"i":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},")":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},"=":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"p":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}}}}},"x":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}}},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}},"l":{"docs":{},"e":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.02112676056338028},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.01834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.018292682926829267},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.02452316076294278},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.03205128205128205},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.01680672268907563},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.020518358531317494},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.03125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.03333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0196078431372549},"advance/cli.html":{"ref":"advance/cli.html","tf":0.022614840989399292},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},",":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.03508771929824561},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.03225806451612903},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.031746031746031744},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"z":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}}}}}},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"\\":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"=":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}}},"l":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.013779527559055118}},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.017082785808147174}},"s":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"t":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"f":{"docs":{},"o":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"/":{"docs":{},"b":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.024096385542168676},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.016181229773462782},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.01838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.022222222222222223},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.00984251968503937},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.008905852417302799},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.023411371237458192},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.02181818181818182},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.01951219512195122},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.022727272727272728},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863}}}}}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}},"l":{"docs":{},"l":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}},"i":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},",":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.00755939524838013},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.692439862542955},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0196078431372549},"advance/cli.html":{"ref":"advance/cli.html","tf":0.007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.04239401496259352}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789}}},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}}}}}}}}}}}}}},"!":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"_":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"n":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}},"g":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.01079913606911447},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806}}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},";":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"v":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"o":{"docs":{},"w":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"a":{"docs":{},"t":{"3":{"2":{"docs":{},")":{"docs":{},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"docs":{}},"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.018867924528301886},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},";":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.02112676056338028},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.01567398119122257},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.01634877384196185},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},")":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464}}},":":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"!":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},",":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}},".":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}},"r":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},".":{"docs":{},".":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}}}}}},"m":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.020689655172413793},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.040983606557377046},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446}}}}},"s":{"docs":{},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},":":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},".":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}}}}}}}},"u":{"docs":{},"m":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"?":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},"c":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}}}}},"t":{"docs":{},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":10.067073170731707},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}},"/":{"docs":{},"/":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}},">":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"d":{"docs":{},"i":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"b":{"docs":{},"_":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075}}}}}}},"s":{"1":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{},"k":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.008728179551122194}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"m":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}}}}}}}}},"c":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.16030534351145037}}}},":":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"f":{"docs":{},"i":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},"p":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}},"m":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}},".":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164}}}}},"w":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.022614840989399292}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"g":{"0":{"1":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":10.123287671232877},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.04580152671755725}},")":{"docs":{"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},".":{"docs":{"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693}}},":":{"docs":{"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}},",":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}},"docs":{}},"1":{"docs":{},"d":{"8":{"docs":{},"b":{"5":{"docs":{},"e":{"5":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"docs":{}}},"docs":{}}},"docs":{}}},"2":{"3":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{}},"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":3.356060606060606}},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"_":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}},"r":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}}}},"u":{"docs":{},"i":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"d":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.02531645569620253},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.01904761904761905},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":5.00253164556962},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}},"e":{"docs":{},",":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},".":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}},"p":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.01904761904761905},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}},"i":{"0":{"8":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},"9":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},"docs":{}},"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":10.040880503144654},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":10.068965517241379},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.04580152671755725}},"o":{"1":{"6":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}},"docs":{}},"2":{"1":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}},"docs":{}},"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.011111111111111112},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"=":{"docs":{},"\"":{"docs":{},"p":{"2":{"0":{"docs":{},"\"":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364}}}}},"docs":{}},"docs":{}}}},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}},"y":{"docs":{},",":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931}}},".":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"_":{"0":{"docs":{},"x":{"1":{"0":{"0":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"a":{"0":{"0":{"0":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}},":":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931}}},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"p":{"docs":{},"i":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"s":{"docs":{},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"l":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"o":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.06818181818181818},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"n":{"docs":{},"e":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}},"e":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}},"o":{"docs":{},"d":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}},"g":{"docs":{},"l":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"e":{"docs":{},"'":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}}}},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"f":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.024844720496894408}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"n":{"docs":{},"d":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"w":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}}},"e":{"docs":{},"n":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}},"i":{"docs":{},"d":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}},"u":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},"n":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.017964071856287425},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.009198423127463863},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},",":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"l":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},":":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"t":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.034383954154727794},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.014778325123152709},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":2.5049627791563274},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}}},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":10.0625},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.026490066225165563},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":10.00943396226415}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":10.006622516556291}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":10.012658227848101}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":10.005714285714285}},"i":{"docs":{},"c":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":10.008771929824562}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273}}}}},"r":{"docs":{},"b":{"docs":{},"a":{"docs":{},"g":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.0975609756097561},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"y":{"docs":{},"p":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"c":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":10.024390243902438}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}},")":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}},".":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}}}}}}}}}}},"b":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"m":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"h":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"advance/cli.html":{"ref":"advance/cli.html","tf":0.02756183745583039}},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"(":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"l":{"docs":{},"o":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"r":{"docs":{},"e":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{},".":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}},":":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},".":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}},"\"":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}},"'":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"b":{"docs":{},"i":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"t":{"docs":{},"z":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.012958963282937365}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"s":{"docs":{},",":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}}}}}},"p":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.013377926421404682},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.07317073170731707}},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}},"x":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"m":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.045454545454545456}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},")":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":5.03125},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.09523809523809523},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"v":{"docs":{},"e":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"l":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818}},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.03636363636363636}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},"_":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}},"docs":{}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},"g":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"l":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}},"f":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}}},"s":{"docs":{},"h":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.034782608695652174},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},",":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}},".":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"_":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}}}}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"l":{"docs":{},"i":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},")":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}},"s":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"l":{"docs":{},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},"s":{"docs":{},"/":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}},"y":{"docs":{},":":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}}}},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}},"e":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}}},"d":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"e":{"docs":{},"r":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"w":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.008445945945945946}},"/":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"m":{"docs":{},"e":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"w":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}},"u":{"docs":{},"r":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"n":{"docs":{},"g":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":10.018518518518519},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012}},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"2":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{},"/":{"docs":{},"/":{"1":{"2":{"7":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},":":{"8":{"0":{"0":{"0":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"?":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"1":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"p":{"docs":{},"/":{"docs":{},"d":{"docs":{},"f":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"1":{"docs":{},".":{"0":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}}}}}}}}}},"1":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}},"docs":{}}},"docs":{}}}}},"u":{"docs":{},"m":{"docs":{},"i":{"docs":{},"d":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.013477088948787063}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"n":{"docs":{},"d":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"z":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"advance/cli.html":{"ref":"advance/cli.html","tf":0.012720848056537103}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.02181818181818182}}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.012720848056537103}}}},"i":{"2":{"docs":{},"c":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":10.028571428571428},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":10.043233082706767},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},"(":{"0":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"docs":{}},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}},".":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},"(":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"2":{"docs":{},"c":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}}}}},"docs":{}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"0":{"docs":{},"x":{"4":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"docs":{}},"docs":{}}},"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"(":{"0":{"docs":{},"x":{"4":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}},"docs":{}},"docs":{}}},"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"0":{"docs":{},"x":{"4":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}},"docs":{}},"docs":{}}},"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},"=":{"0":{"docs":{},"x":{"4":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}},"_":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"(":{"0":{"docs":{},"x":{"4":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}},"docs":{}},"docs":{}}},"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}},";":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"r":{"docs":{},"m":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.023411371237458192},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"”":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}},"a":{"docs":{},"l":{"docs":{},".":{"docs":{"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}}}}}}}}}}}},",":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517}}},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"y":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273}}}}}}}}},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.013368983957219251},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"t":{"docs":{"./":{"ref":"./","tf":10.02127659574468},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":10.00632911392405},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":5.007042253521127},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":10.003703703703703},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":10.01388888888889},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":10.006849315068493},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":10.045454545454545},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":10.007352941176471},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":10.028571428571428}}}}}}}},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616}}}},"\"":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.07142857142857142}}}}},"n":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"e":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.013333333333333334},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.011037527593818985},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.07272727272727272},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.008595988538681949}},"s":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},";":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},".":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"o":{"docs":{},"g":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"v":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259}},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}},"g":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.02631578947368421},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"r":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":10.071428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.031055900621118012}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.031055900621118012},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.020253164556962026},"pymakr/installation/":{"ref":"pymakr/installation/","tf":10.05},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.03169014084507042},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.0219435736677116},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":5.03125},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.02127659574468085},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":2.546153846153846},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":5.006410256410256},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078}}}}},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},".":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}},"c":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}},"e":{"docs":{},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}},")":{"docs":{},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},":":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}},":":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"i":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.025925925925925925},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"documents/license.html":{"ref":"documents/license.html","tf":0.022900763358778626}},"e":{"docs":{},":":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}},"s":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"a":{"docs":{},"s":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213}}},"a":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"o":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}}}}},"m":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"x":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"u":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"p":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02022058823529412},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},",":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"_":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"1":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},"s":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}},"/":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},"i":{"docs":{},"t":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.02586206896551724},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}},":":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.025454545454545455},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}},"n":{"docs":{},"t":{"docs":{},"!":{"docs":{"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}}}}}},"o":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}}}}}}},"o":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905}},"t":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.014457831325301205},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.03333333333333333},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":5.033898305084746},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.010752688172043012},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":5.012422360248447}},".":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},",":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},":":{"docs":{"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}}}},"n":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}}},"p":{"6":{"7":{"docs":{"products.html":{"ref":"products.html","tf":0.02}}},"docs":{}},"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.018633540372670808},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.01152073732718894},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.016483516483516484},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},"v":{"4":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"docs":{}}},"t":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"e":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"r":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}}},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}},"'":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"'":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"!":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.015873015873015872},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}}}}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},"o":{"1":{"4":{"4":{"4":{"3":{"docs":{},"a":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"y":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}}}}},"”":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.01834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.017045454545454544},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.016042780748663103},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.020737327188940093},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.02734375},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.07407407407407407},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.0380952380952381},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.05238095238095238},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.015},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.05},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.04225352112676056},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.026143790849673203},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.02666666666666667},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.009603841536614645},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.013257575757575758},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.028368794326241134},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.019704433497536946},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.02185792349726776},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.019851116625310174},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.05660377358490566},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.02197802197802198},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.10185185185185185},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0625},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.008905852417302799},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.009150326797385621},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.02591792656587473},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.03125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01639344262295082},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"/":{"docs":{},"u":{"docs":{},"s":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},"p":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.007202881152460984},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0273972602739726},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.022222222222222223}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}},"a":{"docs":{},"g":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"e":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"s":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"i":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"e":{"docs":{},"i":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":5.043478260869565},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}},".":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.009198423127463863},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.017191977077363897},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},":":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"d":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.03765690376569038},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.014326647564469915},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.015957446808510637},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"a":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},"l":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},"n":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.013779527559055118},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"t":{"docs":{},"y":{"docs":{},"=":{"docs":{},"'":{"docs":{},"m":{"docs":{},"y":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}},"l":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},"e":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182}}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}},")":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},":":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"x":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"=":{"0":{"docs":{},"x":{"1":{"2":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"docs":{}},"docs":{}}},"docs":{}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}},"f":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}}}},"/":{"docs":{},"o":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},")":{"docs":{},")":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},"r":{"docs":{},"q":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}},"q":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"c":{"docs":{},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"o":{"docs":{},"n":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"v":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.019762845849802372}},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}}}},"j":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.027777777777777776},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.02564102564102564},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.014204545454545454},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.019704433497536946},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00718954248366013}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{},".":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.08888888888888889}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}},"t":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"n":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"m":{"1":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.05},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":5.021978021978022},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},"n":{"docs":{},"b":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}}},"/":{"docs":{},"n":{"docs":{},"b":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603}}}}},",":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781}},"o":{"docs":{},"d":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"u":{"docs":{},"l":{"docs":{"products.html":{"ref":"products.html","tf":0.02},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.02531645569620253},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.0625},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.025495750708215296},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.023809523809523808},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.026239067055393587},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.025157232704402517},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.01927710843373494},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.02857142857142857},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":5.0285714285714285},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.011009174311926606},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.024305555555555556},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.029069767441860465},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.012658227848101266},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.018633540372670808},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":5.043478260869565},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.06164383561643835},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":5.107142857142857},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.09523809523809523},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":5.057142857142857},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.09090909090909091},"datasheets/development/":{"ref":"datasheets/development/","tf":5.055555555555555},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.017543859649122806},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.017467248908296942},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.017777777777777778},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/":{"ref":"datasheets/oem/","tf":5.076923076923077},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}},"e":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.03333333333333333},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}},"/":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},".":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},":":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},")":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"'":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"'":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"u":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.010638297872340425},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.028846153846153848},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.012962962962962963},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.009150326797385621},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.007481296758104738},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},".":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"m":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":3.347372210223182},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.01935483870967742},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},".":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"'":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}},".":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}},",":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},";":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},")":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"s":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},";":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},":":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"=":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391}},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"l":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}},"i":{"docs":{},"f":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}},"e":{"docs":{},"d":{"docs":{},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"y":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"b":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":10.014705882352942}},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.017391304347826087},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},")":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},":":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"(":{"docs":{},"s":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}},"n":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"i":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},"s":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}}}},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}},"'":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}}}},"d":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.03333333333333333},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":5.049295774647887},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":5.006472491909385},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.01675977653631285},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0410958904109589},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":5.0285714285714285},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":10.013377926421406},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.022082018927444796},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}},";":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"_":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"p":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}},"k":{"docs":{},"b":{"docs":{},"d":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"[":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"[":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"[":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"g":{"docs":{},"p":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"p":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}},"m":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"i":{"docs":{},"s":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}},"u":{"docs":{},"m":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"u":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"d":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}},"o":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},")":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"f":{"docs":{},"a":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744}}}}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"s":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},".":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}},"t":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.014778325123152709},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01639344262295082},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.022443890274314215}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.012195121951219513}}}}}},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712}}}}},"l":{"docs":{},"i":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}},"c":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":2.5141843971631204},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":2.502481389578164},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},"o":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"x":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}},":":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}}}}}}},":":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.013257575757575758},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.027777777777777776},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":10.008888888888889},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"=":{"2":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}}}},"3":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"docs":{}},",":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"docs":{}}}}},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}},"i":{"2":{"docs":{},"c":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}},"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}},"d":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}},"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}},"l":{"docs":{},"p":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"(":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},"[":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"2":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"2":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"docs":{}},"docs":{}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}},"(":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"_":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}},"n":{"docs":{},"y":{"docs":{},"_":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}}}}}}},"d":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}},"docs":{}}}}}}}},"a":{"docs":{},"d":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},"docs":{}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}}}}}}}}}},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"s":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"=":{"docs":{},"'":{"docs":{},"g":{"docs":{},"p":{"docs":{},"i":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"r":{"docs":{},"o":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}}}},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}},"'":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815}}}}}}},"i":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"f":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.008403361344537815}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"u":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01171875},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"=":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"_":{"docs":{},"v":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"docs":{}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.676975945017182},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464}}}}},",":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"j":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}},"x":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"=":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"d":{"docs":{},"e":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}},"p":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.05555555555555555},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}}}}}},"h":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":10.007272727272728}},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},".":{"docs":{},"a":{"docs":{},"c":{"docs":{},"o":{"docs":{},"s":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"2":{"docs":{},"(":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}}},"s":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},"r":{"docs":{},"f":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"c":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"x":{"docs":{},"p":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"m":{"1":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"docs":{}}}}},"f":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"r":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"o":{"docs":{},"g":{"1":{"0":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"docs":{}},"2":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"p":{"docs":{},"i":{"docs":{},":":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"q":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"h":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.013157894736842105},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}},"/":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"v":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},":":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}},"k":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"r":{"docs":{},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"l":{"docs":{},"e":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.018796992481203006},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.01079913606911447},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.013140604467805518},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"'":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.01904761904761905},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.013477088948787063},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.020080321285140562},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.011037527593818985},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0058823529411764705},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.02608695652173913},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.012307692307692308},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.05730659025787966},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.04371584699453552},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},")":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"n":{"docs":{},"u":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"a":{"docs":{},"n":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},"e":{"docs":{},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"i":{"docs":{},"s":{"docs":{},"m":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.009925558312655087},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.026785714285714284},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.023622047244094488},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.008728179551122194},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.01342756183745583}},"e":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},"\"":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"!":{"docs":{},"\"":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"s":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}}}},"h":{"docs":{"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":5.117647058823529}}}},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{},"m":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}},"x":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}}}}},"e":{"docs":{},"x":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"'":{"docs":{},"]":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"p":{"docs":{},"l":{"3":{"1":{"1":{"5":{"docs":{},"a":{"2":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"f":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},"r":{"docs":{},"c":{"6":{"3":{"0":{"0":{"2":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}},"docs":{}},"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"f":{"docs":{},"r":{"docs":{},"c":{"6":{"3":{"0":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"o":{"1":{"4":{"4":{"4":{"3":{"docs":{},"a":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}},"w":{"docs":{},"u":{"docs":{},"p":{"docs":{},"a":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"a":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"m":{"docs":{},"f":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}},"p":{"docs":{},"i":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{},"(":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"o":{"1":{"4":{"4":{"4":{"3":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"a":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}},"w":{"docs":{},"u":{"docs":{},"p":{"docs":{},"a":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"m":{"docs":{},"f":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"_":{"docs":{},"b":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"g":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":10.047619047619047},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.013513513513513514},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},".":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}}}},"s":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"g":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},":":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"=":{"docs":{},"\"":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}},"[":{"docs":{},":":{"1":{"6":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}},"docs":{}},"docs":{}}}},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"b":{"docs":{},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"c":{"docs":{},"u":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"/":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"n":{"docs":{},"b":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}}}},"v":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"y":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"1":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"1":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"docs":{}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"d":{"5":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.017391304347826087}}},"docs":{},"a":{"docs":{},"y":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"p":{"1":{"0":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"1":{"docs":{},"=":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}}}}},"2":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},",":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}},"3":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"4":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"5":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"6":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"7":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"8":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},".":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"9":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}},"2":{"0":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"1":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"2":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.026785714285714284},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"3":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},":":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"3":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"4":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},":":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"6":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}},"8":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},":":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}},"/":{"docs":{},"g":{"1":{"5":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"docs":{}},"docs":{}}}},"9":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.01696113074204947}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"t":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"products.html":{"ref":"products.html","tf":5.013333333333334},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"s":{"docs":{},",":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}},".":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},",":{"docs":{"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":3.353516819571865},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},")":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":5.019047619047619},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}}}},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"a":{"docs":{},"t":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.029069767441860465},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.024844720496894408},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.00975609756097561},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}}},"d":{"docs":{},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}}}}}},"s":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.019886363636363636},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}}},"e":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}},"c":{"docs":{},"e":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"s":{"docs":{},"s":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.024096385542168676},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"o":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},":":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"d":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"e":{"docs":{},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},")":{"docs":{},".":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},")":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"s":{"docs":{},".":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"l":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"t":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}}},"h":{"docs":{},"i":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}},"e":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},":":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"c":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"r":{"docs":{},"v":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789}}}}},"s":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0223463687150838},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"u":{"docs":{},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.013477088948787063}},"e":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"s":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}}}}}},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}},"e":{"docs":{},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}}}},"i":{"docs":{},"x":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}}},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},"e":{"docs":{},"=":{"8":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.00998003992015968},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.020066889632107024},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.045454545454545456}},"(":{"1":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}}},"docs":{},"\"":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"i":{"docs":{},"m":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},":":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"p":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}},"e":{"docs":{},"s":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"i":{"docs":{},"n":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"o":{"docs":{},"w":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}},"%":{"0":{"2":{"docs":{},"d":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"docs":{}},"docs":{}},"\\":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},"r":{"docs":{},"%":{"7":{"docs":{},"d":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"n":{"docs":{},"o":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}},"{":{"docs":{},"}":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"g":{"docs":{},"o":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"[":{"docs":{},"'":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"'":{"docs":{},"]":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"_":{"docs":{},"c":{"docs":{},".":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"[":{"2":{"docs":{},"]":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"docs":{}}}}}}}}}},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}}}},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"f":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}}}}}}}}}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}},"x":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"f":{"docs":{},"g":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}},"l":{"docs":{},"t":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}},"o":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"o":{"docs":{},"i":{"docs":{},"l":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}},"u":{"docs":{},"n":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"a":{"docs":{},"w":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}},"d":{"docs":{},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}},"\\":{"docs":{},"n":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}},"{":{"docs":{},"}":{"docs":{},",":{"docs":{},"{":{"docs":{},"}":{"docs":{},"'":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},",":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"_":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"s":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"4":{"0":{"9":{"6":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}},"docs":{}},"docs":{}},"docs":{}},"6":{"4":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}},"docs":{}},"docs":{}}}}}}},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}},"s":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{},".":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}}}}},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"o":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}},"v":{"docs":{},"a":{"docs":{},"c":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}},"l":{"docs":{},"i":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}},"y":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.058823529411764705},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":3.3787878787878785},"pybytes/connect/":{"ref":"pybytes/connect/","tf":3.4054982817869415},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.057692307692307696},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.7439862542955324},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.026881720430107527},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.04918032786885246},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},"e":{"docs":{},"s":{"docs":{},"?":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},".":{"docs":{"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.045454545454545456},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.017964071856287425},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}},":":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":2.5096153846153846},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.6718213058419242}}},";":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},")":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}}},":":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}},".":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}},"s":{"docs":{},"b":{"docs":{},"_":{"docs":{},"v":{"docs":{},"c":{"docs":{},"p":{"docs":{},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"products.html":{"ref":"products.html","tf":5.02},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.07228915662650602},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.01904761904761905},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.012844036697247707},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.031578947368421054},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.017605633802816902},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.01634877384196185},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.06944444444444445},"tutorials/all/":{"ref":"tutorials/all/","tf":3.4999999999999996},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.04225352112676056},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.007202881152460984},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":5.107142857142857},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":10.023758099352051},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.02005730659025788},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.022058823529411766},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.019787985865724382},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"[":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"(":{"docs":{},"[":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"g":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"0":{"docs":{},"x":{"0":{"0":{"0":{"0":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}},"docs":{}},"1":{"5":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"docs":{}},"docs":{}},"docs":{}},"7":{"docs":{},"f":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}},"docs":{}},"docs":{}}},"docs":{},"f":{"docs":{},"f":{"0":{"0":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},"docs":{}},"docs":{}}}},"docs":{}},"1":{"5":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"docs":{},"f":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}},"docs":{}},"docs":{}},"docs":{}},"7":{"docs":{},"f":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"f":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{}}}}},"docs":{},"r":{"docs":{},"g":{"docs":{},"b":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"=":{"0":{"docs":{},"x":{"docs":{},"f":{"docs":{},"f":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}},"n":{"docs":{},"v":{"docs":{},"s":{"docs":{},"_":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"l":{"docs":{},"o":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"d":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"[":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"1":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"[":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"[":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"_":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}},"'":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},"'":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}}},"d":{"docs":{"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943}}}},"a":{"docs":{},"s":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}},"e":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}}}}},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},".":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":10.1},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":3.353516819571865},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.027848101265822784},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.04929577464788732},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.047021943573667714},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.021798365122615803},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.037267080745341616},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.015463917525773196}},".":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},"@":{"1":{"docs":{},".":{"0":{"docs":{},".":{"3":{"docs":{},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"docs":{}}},"docs":{}}},"docs":{}},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":10.007984031936127},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":5.0375},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":10.091836734693878},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},".":{"docs":{"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456}}},"'":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"(":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.03205128205128205},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":10.026954177897574},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0106951871657754},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":5.018518518518518},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":10.131578947368421}},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349}}},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}},")":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"_":{"docs":{},"x":{"docs":{},".":{"docs":{},"x":{"docs":{},".":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},"f":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},",":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}},".":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888}},"p":{"docs":{},"i":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}},":":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"'":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}},"r":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.014184397163120567},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":10.028571428571428},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.01871657754010695},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":5.037037037037037},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":10.131578947368421}},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}}}}}}}}}}}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"_":{"0":{"docs":{},".":{"0":{"docs":{},".":{"8":{"docs":{},".":{"docs":{},"d":{"docs":{},"f":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}},")":{"docs":{},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}},"'":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}},"'":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}},"o":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},"[":{"docs":{},"g":{"docs":{},"p":{"docs":{},"s":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"[":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"e":{"docs":{},"d":{"docs":{},"g":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},")":{"docs":{},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"3":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.028169014084507043},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.022653721682847898},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.010126582278481013},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.03424657534246575},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.04285714285714286},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.015772870662460567},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.08571428571428572},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.022443890274314215}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"d":{"docs":{},"e":{"0":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}}}}}},".":{"docs":{},"g":{"docs":{},"o":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"3":{"0":{"0":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.04602510460251046},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"k":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}},"a":{"docs":{},"g":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.010126582278481013},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.019851116625310174},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},")":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}},":":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},".":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},",":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}}}},"e":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.028846153846153848},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00849673202614379},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"g":{"docs":{},"e":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"s":{"docs":{},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.008445945945945946}}},":":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}},"r":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"i":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/cli.html":{"ref":"advance/cli.html","tf":0.009187279151943463},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"s":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.03424657534246575},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"l":{"docs":{},"i":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}},"a":{"docs":{},"m":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"e":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0063604240282685515},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},".":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446}},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}}},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.016172506738544475},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.011811023622047244},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.017191977077363897},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.0273224043715847}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},"=":{"docs":{},"\"":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}},")":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"\"":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"i":{"docs":{},"v":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513}}}}},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}},"n":{"docs":{},"e":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}},"/":{"docs":{},"b":{"docs":{},"o":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}}},"l":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"i":{"docs":{},"r":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625}}}}}}}},"t":{"docs":{},"h":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"s":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},".":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889}}},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"u":{"docs":{},"s":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"e":{"docs":{},"r":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}},"t":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}},"a":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},"i":{"docs":{},"s":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"_":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"0":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"1":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"docs":{}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},"=":{"1":{"5":{"0":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}},"docs":{}},"docs":{}},"docs":{}},"i":{"docs":{},"c":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}},"a":{"docs":{},"g":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}},"a":{"docs":{},"p":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.015772870662460567},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.07142857142857142}},"s":{"docs":{},":":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}}}}}}}},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}}}}}}}},"n":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.01567398119122257},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.009719222462203024},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.11764705882352941},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}},"u":{"docs":{},"g":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"i":{"docs":{},"n":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.15},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.15},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.021798365122615803},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},":":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"/":{"docs":{},"u":{"docs":{},"n":{"docs":{},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"g":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}}}}}}}}}}}},"o":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"t":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012}},".":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"a":{"docs":{},"l":{"docs":{},";":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},":":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"v":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"x":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.009216589861751152},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.017543859649122806},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.017467248908296942},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.017777777777777778},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.07142857142857142}},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"e":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"e":{"docs":{},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}},",":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"!":{"docs":{},"!":{"docs":{},"!":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"r":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.02100840336134454},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.02054794520547945},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.019081272084805655},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.014962593516209476}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},")":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"a":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272}},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182}}},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"b":{"docs":{},"l":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},".":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}},"s":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"=":{"1":{"8":{"8":{"3":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"/":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}},":":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},"a":{"docs":{},"r":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.008445945945945946}}}}},"a":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811}}}},"docs":{}}}}}}},"l":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.03816793893129771},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"[":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"i":{"docs":{},"g":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.015873015873015872},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.013888888888888888},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.013368983957219251},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0125},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.008888888888888889},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.020080321285140562},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.013157894736842105},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":10.066225165562914},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.024324324324324326},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.02594810379241517},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.012958963282937365},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.02631578947368421},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.027586206896551724},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.026200873362445413},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.024},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.02666666666666667},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.04011461318051576},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.020958083832335328},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01092896174863388}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.013245033112582781},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}}}}}}},"(":{"docs":{},"[":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},".":{"docs":{},"g":{"1":{"6":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},".":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"(":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"r":{"docs":{},"q":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"[":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"e":{"docs":{},".":{"docs":{},"p":{"9":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},".":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},"docs":{}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"[":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}}}}}},")":{"docs":{},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"#":{"6":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},"docs":{}},"(":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"1":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{},"'":{"docs":{},"g":{"1":{"6":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"docs":{}},"4":{"docs":{},"'":{"docs":{},",":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}},"docs":{}},"p":{"1":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391}}}}},"2":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"docs":{}},"9":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"docs":{}}},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"[":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"1":{"6":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"9":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}}}}}}}}}}}}},"\"":{"docs":{},"g":{"7":{"docs":{},"\"":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},"docs":{}}}},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"=":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"1":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{},"'":{"docs":{},"p":{"1":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}}},"docs":{}},"docs":{}}}}}},"2":{"docs":{},"'":{"docs":{},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"9":{"docs":{},"'":{"docs":{},",":{"docs":{},"'":{"docs":{},"p":{"2":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{},"'":{"docs":{},"p":{"2":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"2":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},"'":{"docs":{},"p":{"2":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"docs":{}},"docs":{}}}}}},"2":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496}}}}},"docs":{}},"docs":{}}},"s":{"docs":{},"d":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"c":{"docs":{},"l":{"docs":{},"k":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"t":{"docs":{},"x":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}}},"_":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"=":{"docs":{},"'":{"docs":{},"p":{"1":{"2":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"6":{"docs":{},"'":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.020689655172413793},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.024},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.07894736842105263},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.07894736842105263},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.030612244897959183},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.038461538461538464},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.058823529411764705}},"s":{"docs":{},",":{"docs":{"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}}}}}}},"c":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}},"k":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}},"_":{"docs":{},"r":{"docs":{},"c":{"1":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},"docs":{}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"d":{"docs":{},")":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035}}}}},"e":{"docs":{},"c":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"r":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":5.016666666666667}},"(":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},",":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}},"u":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"t":{"docs":{},"i":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"c":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.017660044150110375},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.02005730659025788}},"=":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"s":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.026515151515151516},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":3.0386965376782076},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789}},"e":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"s":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"_":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"s":{"docs":{},"h":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"r":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}}},"/":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}},"/":{"docs":{},"p":{"docs":{},"c":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223}},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109}}}},"docs":{}}}}},"i":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"p":{"docs":{},"h":{"docs":{},"i":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}}}}}},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}},".":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}},"c":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},".":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"b":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}},"w":{"docs":{},"d":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},")":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"m":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":10.08130081300813},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},"(":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}}},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},".":{"docs":{},"d":{"docs":{},"u":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"3":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}},".":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}},"d":{"docs":{},"u":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"f":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.027586206896551724},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.026490066225165563},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0547945205479452},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.05263157894736842},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.05263157894736842},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.02564102564102564},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098}}}},"k":{"docs":{},"g":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.009925558312655087}},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}}}}}}}},"c":{"docs":{},"s":{"8":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"docs":{}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"1":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}},"s":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"o":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},".":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"r":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},"e":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.01904761904761905},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.015968063872255488},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02389705882352941},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.020080321285140562},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.022556390977443608},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.03792415169660679},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.019867549668874173},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.013108614232209739},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"i":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"e":{"docs":{},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},"s":{"docs":{},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}},":":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"_":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}},"/":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}}}}}}},"y":{"docs":{},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"c":{"docs":{},"h":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},":":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}},"l":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.01904761904761905},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"v":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577}}}}}},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}}}}},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.029556650246305417},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.02185792349726776},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.013779527559055118},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.020366598778004074},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.011235955056179775},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{},".":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},",":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}},"r":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}}}}}}}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}},"n":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334}}}}},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}},"[":{"1":{"docs":{},"]":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"docs":{}},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":5.090909090909091},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.026785714285714284},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":2.5546875},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":2.558333333333333},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01639344262295082}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}},"u":{"docs":{},"s":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.07894736842105263},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.02185792349726776},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"e":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"d":{"docs":{},")":{"docs":{},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}}}}}}}},"a":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.016736401673640166},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.034383954154727794},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.051470588235294115},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082}},"r":{"docs":{"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":5.052631578947368},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.014204545454545454},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}},"\"":{"docs":{},";":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}}}}}}},"i":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}},"=":{"0":{"docs":{},"x":{"0":{"1":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}},"=":{"1":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}},"e":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"docs":{},"[":{"2":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}},"docs":{}}}}}}}}}},"s":{"docs":{},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"o":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},")":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"9":{"1":{"5":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"docs":{}},"docs":{}},"docs":{}}},"e":{"docs":{},"u":{"8":{"6":{"8":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"u":{"docs":{},"l":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.017543859649122806},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.017467248908296942},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.017777777777777778},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"a":{"docs":{},"r":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.03968253968253968},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}},"e":{"docs":{},"x":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.047619047619047616}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}},"d":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"p":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}},"o":{"docs":{},"v":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}},"t":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.012867647058823529},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":6.002036659877801},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985}},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0169971671388102},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.017857142857142856},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.01749271137026239},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.014457831325301205},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.01904761904761905},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.027777777777777776},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0106951871657754},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0223463687150838},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.013333333333333334},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.005653710247349823}},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},";":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"\"":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"n":{"docs":{},"d":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.013257575757575758},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},":":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},":":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136}},"s":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}},".":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}},"t":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}},"o":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}}}}},"i":{"docs":{},"d":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},":":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}},"z":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"l":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"e":{"docs":{},"=":{"docs":{},"'":{"1":{"docs":{},".":{"1":{"7":{"docs":{},".":{"0":{"docs":{},".":{"docs":{},"b":{"1":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}},"docs":{}}}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}},"v":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}}},"i":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}},"p":{"docs":{},"l":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":10.054054054054054},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":5.021052631578947},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":10.005586592178771},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":3.371212121212121}},":":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"a":{"docs":{},"c":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"y":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}},"i":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}}},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.019867549668874173},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.045454545454545456}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}},"y":{"docs":{},".":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}},"r":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.012944983818770227},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.03333333333333333},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.03504043126684636},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.021956087824351298},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0275},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.028888888888888888},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.015037593984962405},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.027944111776447105},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.013994910941475827},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.02830188679245283},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.0759493670886076},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.052980132450331126},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00522875816993464},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.00997506234413965},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.015053763440860216},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.04},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.08888888888888889},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.14545454545454545},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.04878048780487805},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.06060606060606061},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.020599250936329586},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.014634146341463415},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.018461538461538463},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.030303030303030304}},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.014705882352941176}}}}}}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},",":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}},"r":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},"e":{"docs":{},"v":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01171875},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.07633587786259542}},"u":{"docs":{},"c":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"m":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}},"s":{"docs":{},"k":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"e":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.008595988538681949}}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}},"u":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.020833333333333332},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.025688073394495414},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.02278481012658228},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.021798365122615803},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.02586206896551724},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.005653710247349823},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}},":":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"/":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}},"e":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"l":{"docs":{},"e":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}},"t":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}},")":{"docs":{},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}},"s":{"docs":{},"/":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"c":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.027777777777777776},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":10.041420118343195},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.014634146341463415},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}},"t":{"docs":{},"p":{"docs":{},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},".":{"docs":{},"n":{"docs":{},"t":{"docs":{},"p":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"(":{"2":{"0":{"1":{"4":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"7":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}},"(":{"2":{"0":{"1":{"4":{"docs":{},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}}}},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"r":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}}}}}}}}}},"x":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"3":{"2":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}}}}}},"docs":{}},"docs":{}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"docs":{}}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"r":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}},"m":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"o":{"docs":{},"s":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"a":{"5":{"docs":{},")":{"docs":{},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"docs":{},"m":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.013377926421404682},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}},".":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}}}},"n":{"docs":{},"g":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"e":{"docs":{},"(":{"0":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"x":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}},"1":{"0":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}}},"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"2":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"3":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666}}}}},"8":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01}}}}},"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},",":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}}}},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.053763440860215055},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"l":{"docs":{},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"w":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.013725490196078431},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"d":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"i":{"docs":{},"o":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.11235955056179775},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409}},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"a":{"docs":{},"n":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}},"t":{"docs":{},"e":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00718954248366013}},":":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"'":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"i":{"docs":{},"o":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},"r":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"x":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222}},"=":{"2":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629}},"=":{"1":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}}}}}}}}}}}}}}},"q":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"=":{"1":{"2":{"8":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}},"d":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}}}},":":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"/":{"docs":{},"t":{"docs":{},"x":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"g":{"docs":{},"b":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":5.042253521126761},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"_":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}},"c":{"1":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"docs":{},"z":{"1":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282}}},"2":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}},"3":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}},"4":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}},"=":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"r":{"docs":{},"c":{"docs":{},"z":{"1":{"docs":{},")":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616}},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645}},".":{"docs":{},"e":{"docs":{},"u":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},"l":{"docs":{},"l":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035}},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}},")":{"docs":{},")":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}},"e":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"o":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"m":{"0":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0125}},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"b":{"docs":{},"o":{"docs":{},"t":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}},"w":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},"f":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"i":{"docs":{},"d":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408}},"/":{"docs":{},"n":{"docs":{},"f":{"docs":{},"c":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612}}}}}}}}},"s":{"docs":{},"t":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"a":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"\"":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}},"_":{"docs":{},"b":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"m":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":10.058712121212121},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":13.026476578411405}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"=":{"4":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576}}}},"docs":{}}}}}}}}}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222}},")":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"g":{"docs":{},"p":{"docs":{},"i":{"docs":{},"o":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"p":{"2":{"0":{"docs":{},"\"":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}},"docs":{}},"docs":{}}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"=":{"1":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"=":{"5":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"d":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"_":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"2":{"4":{"8":{"3":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":5.033707865168539}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}}}},"s":{"1":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.007481296758104738},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"e":{"docs":{},"c":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.041666666666666664},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},",":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0457516339869281},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0220125786163522},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.014634146341463415},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"l":{"docs":{},"i":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"y":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}},"s":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708}}},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}},"u":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.022443890274314215}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}},":":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":5.002493765586035}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"=":{"docs":{},"o":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.02493765586034913}}}}},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"=":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.007339449541284404},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.018292682926829267},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.02005730659025788},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.014084507042253521},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":10.043478260869565},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.013368983957219251},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.0898876404494382},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.008888888888888889},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02857142857142857},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.02869757174392936},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.023668639053254437},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.015723270440251572},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.011811023622047244},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.018518518518518517},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.013725490196078431},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.008728179551122194},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.02591792656587473},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.009363295880149813},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.012195121951219513},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.015463917525773196},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}},"u":{"docs":{},"p":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":5.03125},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}},":":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},"!":{"docs":{},"!":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":10.007633587786259},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.041237113402061855},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.03278688524590164},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},"*":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"i":{"docs":{},"n":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}},"f":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}},"i":{"2":{"docs":{},"c":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}}},"docs":{},"p":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"d":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}}}}}}},"i":{"docs":{},"n":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.01904761904761905}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}}}}}},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"m":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"_":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}},"s":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943}},"s":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}},"n":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"=":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"&":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"=":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"&":{"docs":{},"i":{"docs":{},"d":{"docs":{},"x":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"i":{"docs":{},"d":{"docs":{},"x":{"docs":{},"+":{"docs":{},"\"":{"docs":{},"&":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"&":{"docs":{},"v":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"=":{"0":{"docs":{},"&":{"docs":{},"v":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"+":{"docs":{},"\"":{"docs":{},"&":{"docs":{},"v":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"l":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"r":{"docs":{},"v":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.018292682926829267},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.012004801920768308},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":10.094827586206897},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.02631578947368421},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}},".":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"'":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}},"_":{"docs":{},"i":{"docs":{},"p":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"*":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"=":{"docs":{},"(":{"docs":{},"'":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"3":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}},"[":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"=":{"docs":{},"(":{"docs":{},"'":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.01272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.02830188679245283},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.05063291139240506},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.043859649122807015},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}}}}},"(":{"docs":{},"'":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}},"o":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}},"s":{"docs":{},".":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}}},"​":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"=":{"docs":{},"b":{"docs":{},"'":{"1":{"2":{"3":{"4":{"5":{"6":{"7":{"8":{"9":{"0":{"1":{"2":{"3":{"4":{"5":{"6":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},"i":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"a":{"docs":{},"l":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":3.371148459383753},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.02464788732394366},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.025078369905956112},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.015463917525773196},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506}}}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},".":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}}},"=":{"docs":{},"p":{"docs":{},"y":{"3":{"4":{"3":{"4":{"3":{"4":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872}},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"g":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}},"t":{"docs":{"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549}}}},"e":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"n":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}}},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"n":{"docs":{},"s":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.040740740740740744},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.016172506738544475},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.023809523809523808},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":5.013333333333334},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"s":{"docs":{},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},":":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}}},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}}}},"d":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.024630541871921183},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.02185792349726776},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.00984251968503937},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.017456359102244388},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"s":{"docs":{},"m":{"docs":{},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"p":{"docs":{},"h":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}}}},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":10.022727272727273}}}},"t":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}}}}}}},"m":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}},"p":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}},"a":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}}}}}}}},"c":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.04017857142857143},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}},"a":{"docs":{},"n":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0273972602739726}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"g":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422}},"_":{"docs":{},"s":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}}}}},"i":{"7":{"0":{"0":{"6":{"docs":{},"a":{"2":{"0":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825}},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"i":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},"e":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}},".":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{"products.html":{"ref":"products.html","tf":0.02},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":10.163179916317992},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":5.0625},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":10.058603491271821},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":3.4681647940074902},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.11290322580645161},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.13934426229508196},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},")":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476}}}},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}}}}}}}},"f":{"docs":{},"s":{"docs":{},"k":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}}}}}}}}}}}}}}}}}},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}},"s":{"docs":{},"k":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"[":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"z":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}},"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}},"3":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}},"4":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"n":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273}},"a":{"docs":{},"l":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.017045454545454544},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.02694610778443114}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"s":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"'":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}},"e":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759}}}}}}}},"p":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":10.03206997084548},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":10.044444444444444},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}}},"y":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},".":{"docs":{"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428}}},":":{"docs":{"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},"m":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.05555555555555555},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},".":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735}}},"p":{"docs":{},"l":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"i":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"f":{"docs":{},"i":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}},"u":{"docs":{},"l":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},"d":{"docs":{},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"s":{"docs":{},".":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}},".":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},")":{"docs":{"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"z":{"docs":{},"e":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.01240694789081886},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.012307692307692308}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"=":{"0":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},"docs":{}},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"/":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}},"a":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"e":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.014545454545454545}}},"w":{"docs":{},"a":{"docs":{},"v":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}},"t":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},"a":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.009398496240601503},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.008905852417302799},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":3.3787878787878785},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806}}},":":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}},"!":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236}}},"=":{"0":{"docs":{},"x":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}}},"docs":{}}}}}}}}}}}}},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}},"=":{"docs":{},"r":{"docs":{},"m":{"docs":{},"t":{"docs":{},".":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}}}}},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"b":{"docs":{},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"t":{"docs":{},"e":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00522875816993464},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"(":{"2":{"docs":{},")":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"docs":{}},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}},"i":{"docs":{},"c":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516}},"s":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"docs":{}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883}}},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.02054794520547945},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.04285714285714286},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}}},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}},"c":{"docs":{},"k":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.015384615384615385}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}},"y":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}},"r":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"a":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}},",":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.02759526938239159},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},":":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"\"":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655}}}}}},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},">":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}},"n":{"docs":{},"g":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},".":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}}},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.06060606060606061},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.023809523809523808}}}}}},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.022900763358778626},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634}}},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"]":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},"]":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},"]":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}},"i":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"e":{"docs":{},"p":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.03164556962025317},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.045454545454545456},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.028846153846153848},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.015463917525773196},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.014970059880239521}},"s":{"docs":{},":":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},":":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}},"f":{"docs":{},"a":{"docs":{},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":3.3490073145245556},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}},"c":{"docs":{},"k":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},",":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}}}},":":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}},"a":{"docs":{},"g":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}},"p":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},".":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}}}}}}},"=":{"1":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.04878048780487805},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}}}}},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}}},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334}}},",":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.06666666666666667},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.004987531172069825},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.023809523809523808},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}},"e":{"docs":{},"r":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}},"s":{"docs":{},"s":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"y":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},",":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"!":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"'":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266}}}}}}}},"h":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"i":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"e":{"docs":{},".":{"docs":{"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}}}}}}},"b":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"r":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}},"p":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"i":{"docs":{},"b":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"e":{"docs":{},"t":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.02054794520547945},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.015873015873015872}}},"q":{"docs":{},"u":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"y":{"docs":{},"p":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213}},")":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"m":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"n":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"o":{"docs":{},",":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"f":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.01675977653631285},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":10.012048192771084},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":5.03125},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"documents/license.html":{"ref":"documents/license.html","tf":0.04580152671755725}},"e":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}},"h":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}}}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}},":":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303}}},"c":{"docs":{},"k":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"e":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.014184397163120567},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.024630541871921183},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.0273224043715847},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.009150326797385621},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.02369077306733167},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.06741573033707865},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0390625}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0149812734082397}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"f":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.007481296758104738}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}}}}},"_":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.007481296758104738}}}}}},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}}}}}}}}}}},"_":{"docs":{},"d":{"docs":{},"r":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}},"r":{"docs":{},"x":{"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"e":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}}},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"t":{"docs":{},"x":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}},"l":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}},"t":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"f":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"[":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"'":{"docs":{},"r":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},":":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}}},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"docs":{}}},"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.017721518987341773}}},"!":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}},".":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}},":":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},":":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}},"=":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"r":{"docs":{},"c":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"r":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},".":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.023321554770318022}},"n":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}}}}}}},"r":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},".":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301}}},"e":{"docs":{},"r":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}}}},"c":{"docs":{},"k":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"a":{"1":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323}}},"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826}},"r":{"docs":{},"e":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136}}}}},"p":{"docs":{},"e":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"l":{"docs":{},"l":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}}},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/":{"ref":"datasheets/boards/","tf":3.3888888888888884},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":3.411764705882353},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},".":{"docs":{"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555}}}},"\"":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}},".":{"docs":{"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},",":{"docs":{"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}}}}},"l":{"docs":{},"l":{"docs":{},".":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.019230769230769232},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"p":{"docs":{},"l":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},"e":{"docs":{},".":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}}}},"f":{"docs":{},"e":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":5.013888888888889},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"w":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735}}},"e":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}},".":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419}}},":":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.007339449541284404},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":3.371212121212121},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}},"a":{"docs":{},"n":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.03515625},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.011450381679389313},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"l":{"docs":{},"e":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"a":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.017082785808147174}}},"b":{"docs":{},"l":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}},"h":{"docs":{},"m":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}},"a":{"docs":{},"t":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0234375},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098}}}}}}},"l":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}},"=":{"docs":{},"'":{"docs":{},"p":{"2":{"1":{"docs":{},"'":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"docs":{}},"docs":{}}}},")":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"k":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"k":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":10.03475935828877},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.017543859649122806},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.017467248908296942},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.017777777777777778},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":3.4705882352941173},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":3.356255969436485},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915}}},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},"_":{"docs":{},"u":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}},"s":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}},"4":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"2":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"8":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"docs":{}},"6":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"m":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"s":{"docs":{},"(":{"2":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"(":{"5":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{}}}}},"o":{"docs":{},"w":{"docs":{},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}},"t":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}},".":{"docs":{"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}}},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.014705882352941176},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.03759398496240601},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"=":{"0":{"docs":{},"x":{"0":{"docs":{},"a":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.014705882352941176}}}},"docs":{}}},"docs":{}}}}}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}}}}}}}},"m":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"a":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603}},"l":{"docs":{},"l":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"r":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}},"r":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}},"c":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}},"s":{"docs":{},".":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"s":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625}},"i":{"docs":{},"d":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}},"g":{"docs":{},"p":{"docs":{},"i":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146}}}}}},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"=":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"'":{"docs":{},"w":{"docs":{},"i":{"docs":{},"p":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"d":{"docs":{},".":{"docs":{},"b":{"docs":{},"l":{"docs":{},"y":{"docs":{},"n":{"docs":{},"k":{"docs":{},".":{"docs":{},"c":{"docs":{},"c":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}}}},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.05555555555555555},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.03125}},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"_":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517}}}},"s":{"docs":{},")":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},",":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}},":":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}},"e":{"docs":{},"a":{"docs":{},"y":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"f":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.09523809523809523},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01092896174863388},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"i":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.02443609022556391},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.015384615384615385},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.018633540372670808},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01092896174863388},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.011029411764705883},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},".":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"m":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"e":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/cli.html":{"ref":"advance/cli.html","tf":0.005653710247349823}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"w":{"docs":{},"n":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666}}}},"n":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811}}}}}},"i":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":10.054054054054054},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},",":{"docs":{"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}},"(":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109}}}},"docs":{}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}}}},"l":{"docs":{},"s":{"docs":{},"b":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}}}}}},"s":{"docs":{},"b":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{},"n":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"[":{"0":{"docs":{},"x":{"0":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"[":{"0":{"docs":{},"x":{"0":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"x":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"k":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}}}},"y":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":10.003154574132493}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":10.005464480874316}},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"c":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}},"'":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}},"\"":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}},";":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"docs":{}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"v":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"s":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}},"i":{"docs":{},"n":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}}}}},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.014038876889848811},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":10.089655172413794},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},"a":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},"=":{"docs":{},"'":{"docs":{},"p":{"2":{"2":{"docs":{},"'":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"docs":{}},"docs":{}}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"(":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},"docs":{}}}}}}}}}}},"n":{"6":{"5":{"docs":{},"h":{"docs":{},"v":{"docs":{},"d":{"2":{"3":{"0":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{},"i":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},":":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}},"f":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"i":{"docs":{},"p":{"docs":{},",":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"b":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"[":{"0":{"docs":{},"x":{"0":{"1":{"docs":{},",":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"4":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{}},"docs":{}}},"1":{"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369}}}},"docs":{}}}}}}}},"'":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"'":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943}}}}}}}},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}}}}}}}},"t":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},",":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.011221945137157107}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"5":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"docs":{}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"1":{"2":{"8":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"3":{"2":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}},"6":{"4":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}},"docs":{}},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"1":{"2":{"8":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"docs":{}}}}}}},"f":{"7":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}},"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"=":{"1":{"2":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"7":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"r":{"docs":{},"x":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"t":{"docs":{},"x":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"q":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577}},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"/":{"docs":{},"s":{"docs":{},"d":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"docs":{}}}}},"n":{"docs":{},"b":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"docs":{}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},",":{"docs":{},"'":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},"r":{"docs":{},"v":{"1":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"(":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"docs":{},"b":{"docs":{},"'":{"docs":{},"a":{"docs":{},"b":{"3":{"4":{"5":{"6":{"7":{"8":{"9":{"0":{"1":{"2":{"3":{"4":{"5":{"6":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}},"t":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}},"e":{"docs":{},"e":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552}}}}}}},"a":{"docs":{},"d":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":10.083333333333334},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.05846153846153846},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"i":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"_":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":5.01432664756447},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.018633540372670808}},"s":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"'":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"r":{"docs":{},"d":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.05714285714285714}}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"'":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"'":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}},"!":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"m":{"docs":{},",":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}},".":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}},"“":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"'":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}},"u":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.04819277108433735},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0196078431372549},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},"/":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":10.002724795640328}}}}}}}}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}},"k":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}},"g":{"docs":{},"l":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}},":":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"p":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}},"i":{"docs":{},"c":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}},"s":{"docs":{},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"t":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365}}}}}}},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}},".":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}}}}},"n":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143}}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.06382978723404255},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.05555555555555555},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.020689655172413793},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.024},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.05263157894736842},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.04838709677419355},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.047619047619047616},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},",":{"docs":{"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888}}}},".":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}},"p":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.011111111111111112},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}},"e":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},":":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"r":{"docs":{},"n":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"a":{"docs":{},"b":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"l":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513}}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},";":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}},"k":{"docs":{},"e":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.03508771929824561},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"n":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"i":{"docs":{},"l":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"r":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},":":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"=":{"docs":{},"[":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"|":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"]":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}}}}}}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"[":{"docs":{},".":{"docs":{},"g":{"docs":{},"z":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"l":{"docs":{},"k":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}},"e":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"s":{"docs":{},"k":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01818181818181818}}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.02127659574468085},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.03773584905660377},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.012219959266802444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.03902439024390244},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"5":{"0":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}},"docs":{}},"docs":{}},"1":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"2":{"5":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099}}}},"docs":{}},"5":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}}},"docs":{}}},"1":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}},".":{"2":{"5":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"docs":{}},"5":{"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},"docs":{}}},"2":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}},".":{"5":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"4":{"docs":{},")":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}},"5":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886}}}},"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}}}}}}}}}}}}},".":{"5":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}},"docs":{}}},"_":{"docs":{},"u":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}},"m":{"docs":{},"s":{"docs":{},"(":{"1":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}}}},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.034482758620689655},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.034482758620689655},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.012958963282937365},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232}},"=":{"0":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}},"1":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"docs":{}},"5":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}},"docs":{}},"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},"s":{"docs":{},"=":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{}}}}}}},"m":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},")":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"r":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":10.019607843137255},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":10.022012578616351},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},".":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.00975609756097561}}},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"p":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}},"c":{"docs":{},"k":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"e":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"s":{"docs":{},"_":{"docs":{},"*":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"c":{"docs":{},"p":{"docs":{},"u":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"m":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}},"l":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"n":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}},"e":{"docs":{},"l":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":5.052631578947368},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"x":{"docs":{},"t":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419}},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},":":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"/":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"y":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}},"s":{"docs":{},".":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},":":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"m":{"docs":{},"p":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.012944983818770227},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0215633423180593},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"e":{"docs":{},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"l":{"docs":{},"s":{"docs":{},"b":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"i":{"docs":{},"c":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}},"r":{"docs":{},"i":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}},"c":{"docs":{},"k":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},",":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.011037527593818985},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.02865329512893983}},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},"=":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"r":{"docs":{},"q":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"x":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},".":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.00755939524838013}},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415}}},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"t":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"c":{"docs":{},"e":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.022058823529411766}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"s":{"docs":{},"h":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}},"u":{"docs":{},"e":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"/":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},":":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01171875},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.018633540372670808},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282}}},"]":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}}}}},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},"a":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":5.00253164556962},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}},"w":{"docs":{},"o":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},"'":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"x":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"t":{"docs":{},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}},"_":{"docs":{},"i":{"docs":{},"q":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"docs":{},"r":{"docs":{},"m":{"docs":{},"t":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182}}},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222}},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"y":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"p":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"=":{"1":{"4":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"docs":{}},"docs":{}}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},"e":{"docs":{},"s":{"docs":{},"=":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}},":":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}},"d":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"/":{"docs":{},"r":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"y":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}},"p":{"docs":{},"e":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.010512483574244415},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.02459016393442623},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"d":{"docs":{},".":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},":":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}},"t":{"docs":{},"y":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}}},"n":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},"l":{"docs":{},"s":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}},"l":{"docs":{},"s":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"c":{"docs":{},"p":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415}},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}},"z":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},"]":{"docs":{},"]":{"docs":{},"]":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}}}}}}},"v":{"0":{"docs":{},".":{"9":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}}},"1":{"docs":{},".":{"0":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"1":{"8":{"docs":{},".":{"1":{"docs":{},".":{"docs":{},"r":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"docs":{}}}},"docs":{}}},"docs":{}},"4":{"docs":{},".":{"6":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"docs":{}}},"docs":{}},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164}}}},"2":{"docs":{},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164}}},".":{"0":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"docs":{}}},"3":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0070921985815602835}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},".":{"0":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"docs":{}}},"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}},"o":{"docs":{},"u":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.012944983818770227},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},",":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},")":{"docs":{},".":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}},"t":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}},"l":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}},"u":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.01904761904761905},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0215633423180593},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.00998003992015968},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.015555555555555555},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.0321285140562249},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02857142857142857},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.019867549668874173},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.032520325203252036},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.015748031496062992},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.006361323155216285},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.06622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.04},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.01437908496732026},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.011221945137157107},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.02159827213822894},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.02102496714848883},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.022082018927444796},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.014545454545454545},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.016853932584269662},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.040983606557377046},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.012307692307692308},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.030054644808743168},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},")":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}}},"=":{"1":{"docs":{},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"2":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}},"docs":{}},"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"docs":{}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},":":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.011976047904191617},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.02459016393442623}}},":":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446}}}}}}}}},"i":{"docs":{},"d":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.030379746835443037},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.01800720288115246},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.011879049676025918},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.026143790849673203},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},";":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"s":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"=":{"docs":{},"'":{"docs":{},"v":{"1":{"docs":{},".":{"8":{"docs":{},".":{"6":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},"docs":{}}},"docs":{}}},"docs":{}}}},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"a":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"i":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"f":{"docs":{"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}},"i":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},":":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.013377926421404682},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"e":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"r":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}}},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}},"e":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},")":{"docs":{},":":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}},"i":{"docs":{},"a":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.02464788732394366},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.018808777429467086},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},",":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}},":":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}},"e":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525}}}}}},"t":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":3.3490073145245556},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"i":{"docs":{},"s":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":3.3423153692614767}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}}}}}}},"e":{"docs":{},"w":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}},"c":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"d":{"docs":{},":":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"4":{"docs":{},"d":{"8":{"docs":{},":":{"docs":{},"f":{"0":{"1":{"3":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}},"s":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":3.340909090909091}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543}},".":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}}}}}},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.03571428571428571},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872}},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},".":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}}}}},"d":{"docs":{},"a":{"docs":{},"f":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428}}}}},"d":{"docs":{},"d":{"docs":{},"/":{"2":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"docs":{}}}},"p":{"docs":{},"p":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}},",":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},".":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}}},":":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"w":{"0":{"1":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":10.140350877192983},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.03816793893129771}},",":{"docs":{"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666}}},":":{"docs":{"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806}}}},"docs":{}},"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},"_":{"docs":{},"p":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}},"l":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},",":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"'":{"docs":{},"v":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"r":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"b":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}},"e":{"docs":{},".":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}},"e":{"docs":{},"k":{"docs":{},",":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}},"l":{"docs":{},"i":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"i":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023}},"f":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.015789473684210527},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.012962962962962963},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.027586206896551724},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.032},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.027586206896551724},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.026490066225165563},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.007067137809187279}},"/":{"docs":{},"b":{"docs":{},"t":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}}}}}}}},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}}},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"w":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}},"(":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"_":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":10.041269841269841},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":5.017543859649122},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":5.020689655172414},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.05343511450381679}}},"y":{"2":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.02631578947368421}},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015}}},":":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015}}}},"3":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.04827586206896552}},",":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}},":":{"docs":{"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}},"docs":{},",":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}},".":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},":":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}},"r":{"docs":{},"e":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}}}}}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.037267080745341616},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":2.546153846153846},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"s":{"docs":{},",":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"x":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},";":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},":":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"documents/license.html":{"ref":"documents/license.html","tf":0.022900763358778626}}}}},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"s":{"docs":{},"h":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0196078431372549}}}},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"e":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.02694610778443114}},"'":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"s":{"docs":{},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}},"z":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},",":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}}}}}}},"a":{"docs":{},"y":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"s":{"docs":{},";":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},",":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"r":{"docs":{},"n":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}}}}}},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}},"l":{"docs":{},"k":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},"i":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.01904761904761905},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.009925558312655087},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.030534351145038167},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}}}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}}}}}}}},"v":{"docs":{},"e":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}},"k":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.013333333333333334},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.025787965616045846}},"_":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"_":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}}}}}}}}}},"s":{"docs":{},"[":{"docs":{},"'":{"docs":{},"w":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"'":{"docs":{},"]":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0213903743315508},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667}},".":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789}}}}}}},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"c":{"docs":{},"h":{"docs":{},"d":{"docs":{},"o":{"docs":{},"g":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436}}}}}}}}},"l":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}},"a":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":10.039170506912443},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.01},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":10.022222222222222},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"(":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"(":{"docs":{},"[":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"[":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"m":{"docs":{},"y":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"docs":{},"'":{"docs":{},"m":{"docs":{},"y":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"\"":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"[":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"=":{"docs":{},"(":{"docs":{},"'":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"0":{"docs":{},".":{"1":{"0":{"7":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},"docs":{}},"docs":{}},"4":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},"docs":{}}},"1":{"7":{"8":{"docs":{},".":{"1":{"0":{"7":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"docs":{}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},"a":{"docs":{},"p":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"[":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"[":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},"_":{"docs":{},"a":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"_":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556}}}}},"p":{"docs":{},"a":{"2":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},"_":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}},"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556}}}}}}},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}},",":{"docs":{"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571}}},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},".":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"=":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"[":{"docs":{},"'":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"'":{"docs":{},"]":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},".":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}},"a":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"d":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}},"'":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"b":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},".":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}},"e":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02022058823529412},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.009398496240601503},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.010810810810810811},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0063604240282685515}},"_":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}},"u":{"docs":{},"f":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},".":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}},"=":{"0":{"docs":{},"x":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}}}},"docs":{}},"docs":{}}},"docs":{}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666}}}}}}}},"a":{"docs":{},"p":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}}},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}},"t":{"docs":{},"e":{"docs":{"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549}}}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"s":{"docs":{},"e":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}},"u":{"docs":{},"p":{"docs":{},"a":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"p":{"docs":{},"a":{"2":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"docs":{}}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}},"d":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":10.091954022988507},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.012958963282937365}},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"=":{"2":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.022988505747126436}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}}}}}}}}}}}}}},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"s":{"2":{"8":{"1":{"2":{"docs":{},"b":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}}}},"y":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"'":{"docs":{},"v":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204}}},"l":{"docs":{},"l":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"'":{"docs":{},"r":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"v":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},"l":{"docs":{},"l":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},"?":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"t":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521}}}}}}},"u":{"docs":{},"m":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"a":{"docs":{},"w":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}}}},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091}}},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273}}},"/":{"docs":{},"x":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}},"#":{"0":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.016181229773462782},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.02556818181818182},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.053475935828877004},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.018433179723502304},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.02734375},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.02702702702702703},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.026785714285714284},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0175},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.07042253521126761},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.021608643457382955},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.04924242424242424},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.07801418439716312},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.08374384236453201},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.08743169398907104},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.04962779156327544},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.09433962264150944},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.022321428571428572},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.016483516483516484},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.037037037037037035},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02857142857142857},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.041353383458646614},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.023668639053254437},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.02702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.027944111776447105},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.017716535433070866},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.014256619144602852},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.012962962962962963},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.05172413793103448},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.011450381679389313},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.02830188679245283},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.03137254901960784},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.03366583541147132},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.028077753779697623},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.015772870662460567},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.014326647564469915},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01912568306010929},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.06060606060606061},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.012468827930174564}},"#":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},"#":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}},"#":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"{":{"docs":{},"}":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"m":{"docs":{},"q":{"docs":{},"t":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}},"!":{"docs":{},"/":{"docs":{},"u":{"docs":{},"s":{"docs":{},"r":{"docs":{},"/":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"/":{"docs":{},"e":{"docs":{},"n":{"docs":{},"v":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}}}},")":{"docs":{},":":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"(":{"0":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},"x":{"0":{"2":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"4":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"1":{"docs":{},"a":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"2":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{},"f":{"0":{"1":{"3":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"4":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"docs":{}},"docs":{}},"docs":{}}},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},".":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"0":{"docs":{},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"docs":{}}},"1":{"0":{"0":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{},".":{"1":{"1":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}},"docs":{}},"docs":{}}},"6":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},".":{"1":{"9":{"docs":{},".":{"0":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"docs":{}}},"docs":{}},"docs":{}},",":{"0":{"docs":{},",":{"1":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},",":{"0":{"docs":{},",":{"1":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"1":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}}},"1":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"2":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"docs":{}},"3":{"docs":{},")":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}},"docs":{},"g":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"*":{"docs":{},"*":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}}},"3":{"0":{"0":{"0":{"0":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},"docs":{}},"docs":{}},"docs":{}},"2":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"4":{"0":{"0":{"docs":{},",":{"2":{"0":{"0":{"docs":{},",":{"1":{"0":{"0":{"docs":{},",":{"3":{"0":{"0":{"docs":{},",":{"2":{"0":{"0":{"docs":{},",":{"4":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"k":{"docs":{},"i":{"docs":{},"b":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"8":{"0":{"0":{"0":{"docs":{},",":{"1":{"1":{"0":{"0":{"0":{"docs":{},",":{"8":{"0":{"0":{"0":{"docs":{},",":{"1":{"1":{"0":{"0":{"0":{"docs":{},",":{"6":{"0":{"0":{"0":{"docs":{},",":{"1":{"3":{"0":{"0":{"0":{"docs":{},",":{"6":{"0":{"0":{"0":{"docs":{},",":{"3":{"0":{"0":{"0":{"docs":{},",":{"8":{"0":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"6":{"8":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}},"docs":{}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}},"s":{"docs":{},"e":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"r":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":3.337535014005602}}}}}},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"_":{"docs":{},"h":{"docs":{},"z":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}}},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}}}}}}}}},"l":{"0":{"1":{"docs":{},",":{"docs":{"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}}},"docs":{}},"7":{"6":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},"docs":{}},"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525}}}}},"r":{"docs":{},"a":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"w":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}},"p":{"docs":{},"y":{"4":{"docs":{},",":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}},"docs":{},",":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}},"i":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},"i":{"docs":{},"s":{"2":{"docs":{},"h":{"docs":{},"h":{"1":{"2":{"docs":{},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}}}},"docs":{}},"k":{"docs":{},"e":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"t":{"docs":{},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"e":{"docs":{},"n":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"p":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"a":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"n":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"/":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}}}}}},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"r":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634}}},"b":{"docs":{},"j":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}},"p":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"1":{"0":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}},"=":{"docs":{},"s":{"docs":{},"d":{"docs":{},"a":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013}}}}}}}},"2":{"docs":{},")":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931}}}},"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},")":{"docs":{},",":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}}},"a":{"docs":{},")":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}},"c":{"docs":{},"k":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}},"i":{"docs":{},"c":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877}}},"n":{"docs":{},"#":{"6":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},"docs":{}},"=":{"docs":{},"'":{"docs":{},"p":{"1":{"2":{"docs":{},"'":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"docs":{}},"docs":{}}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}}},"e":{"docs":{},".":{"docs":{},"g":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},",":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}},"r":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"u":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"g":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}}},"m":{"docs":{},"e":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},"c":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},"e":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}},"o":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"_":{"docs":{},"*":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"c":{"docs":{},"l":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112}}}}}},"d":{"docs":{},"a":{"docs":{},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}}}},"i":{"7":{"0":{"0":{"6":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}},"a":{"2":{"0":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}},"y":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"=":{"docs":{},"'":{"docs":{},"g":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"p":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}}},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"q":{"2":{"4":{"0":{"4":{"0":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514}}}}},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"6":{"4":{"docs":{},")":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{}},"docs":{}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"a":{"docs":{},"d":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"p":{"docs":{},"l":{"docs":{},")":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}},"c":{"docs":{},"v":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},")":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112}}}}}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629}}}}}}}}}}}},"g":{"docs":{},"b":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},"_":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}}},"a":{"docs":{},"w":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":2.50709219858156}}}},"t":{"docs":{},"r":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}},"c":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"x":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}},"b":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"'":{"1":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"1":{"4":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"docs":{}},"docs":{}},"8":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{},"w":{"docs":{},"i":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},"c":{"docs":{},")":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238}}}}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},":":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},")":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"v":{"docs":{},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"o":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"z":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"f":{"0":{"1":{"3":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"4":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"docs":{}},"docs":{}},"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},".":{"docs":{},"e":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"f":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}},"n":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}},"p":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}},"v":{"4":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}}}},"docs":{}}},"t":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}},"'":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"=":{"0":{"docs":{},"x":{"0":{"1":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"v":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}},"t":{"docs":{},")":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"f":{"docs":{},"r":{"docs":{},"c":{"6":{"3":{"0":{"0":{"2":{"docs":{},"h":{"docs":{},"n":{"docs":{},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}}}},"docs":{},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"docs":{},"_":{"docs":{},"m":{"docs":{},"f":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"_":{"docs":{},"a":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}},"p":{"docs":{},"l":{"3":{"1":{"1":{"5":{"docs":{},"a":{"2":{"docs":{},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}},"c":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"y":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"j":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}},"n":{"docs":{},"i":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"k":{"docs":{},"e":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}},"x":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}}}}},",":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"o":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}},"t":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.022222222222222223}},"e":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},":":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943}}}}}}},"f":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},"i":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}},"a":{"docs":{},"t":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"t":{"docs":{},"n":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}},"e":{"docs":{},"l":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}},"m":{"docs":{},"p":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},")":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"z":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}},"x":{"1":{"docs":{},"/":{"docs":{},"r":{"docs":{},"x":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}}}},"docs":{}}}}},"docs":{},"d":{"docs":{},"/":{"docs":{},"r":{"docs":{},"x":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}}},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"a":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"p":{"docs":{},")":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},"p":{"docs":{},"e":{"docs":{},"u":{"docs":{},"i":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"l":{"docs":{},"e":{"docs":{},"'":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},"m":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},"b":{"docs":{},"p":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"q":{"docs":{},"a":{"docs":{},")":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}},"t":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"m":{"docs":{},"a":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}},"l":{"docs":{},"s":{"docs":{},"o":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}},"l":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}},"e":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.011857707509881422}}},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}},"u":{"docs":{},"r":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182}}}},"n":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}},"d":{"docs":{},"c":{"docs":{},")":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"n":{"docs":{},"g":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}},"k":{"docs":{},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}}}},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}}}},"r":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}},"s":{"docs":{},"v":{"docs":{},")":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}},")":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}},"e":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}},"~":{"0":{"docs":{},".":{"4":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},"8":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},"docs":{}}},"1":{"docs":{},"u":{"docs":{},"a":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}}},".":{"5":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},"docs":{}}},"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}},"g":{"docs":{},")":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}},"a":{"docs":{},"p":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}}}},"%":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125}}}},"*":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"docs":{}}}}}}},"l":{"docs":{},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"[":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}},"~":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"e":{"docs":{},"p":{"docs":{},"y":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}},"v":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"i":{"docs":{},"a":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"`":{"docs":{},"`":{"docs":{},"p":{"1":{"0":{"docs":{},"`":{"docs":{},"`":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"9":{"docs":{},"`":{"docs":{},"`":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"docs":{}},"2":{"0":{"docs":{},"`":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"docs":{}},"3":{"docs":{},"`":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}},"docs":{}}}},">":{"docs":{},"=":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}},"\"":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}},"{":{"docs":{},"m":{"docs":{},",":{"docs":{},"n":{"docs":{},"}":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}},"x":{"8":{"6":{"docs":{},")":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}},"c":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.02027027027027027},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"a":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"b":{"docs":{},"l":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"e":{"docs":{},"/":{"docs":{},"w":{"docs":{},"i":{"docs":{},"r":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}},"s":{"docs":{},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},".":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}},"s":{"docs":{},"e":{"docs":{"products.html":{"ref":"products.html","tf":0.02},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0058823529411764705},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"t":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.014457831325301205},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.05},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":5.021978021978022},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},"m":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}}},"docs":{}},"e":{"docs":{},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},"s":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}}}}}}},"r":{"docs":{},"d":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.011879049676025918},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.05517241379310345},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}},")":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}},"'":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"e":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},":":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}},"r":{"docs":{},"i":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.03333333333333333},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}},"'":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814}}},"_":{"docs":{},"d":{"docs":{},"u":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"_":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}},"'":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"(":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"a":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}}}}}}}}}}}}},"x":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"f":{"docs":{},"o":{"docs":{},"_":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"=":{"0":{"docs":{},"x":{"0":{"0":{"2":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"1":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{}}},"1":{"2":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}}}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},"(":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"o":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}},"o":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"gettingstarted/installation/pymakr.html":{"ref":"gettingstarted/installation/pymakr.html","tf":0.05},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/":{"ref":"pymakr/installation/","tf":0.05},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.017142857142857144},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.021505376344086023}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},":":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.0625},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.012195121951219513}}}}}}}},"p":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}}},"i":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655}}}}}},"_":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"s":{"docs":{},"=":{"docs":{},"'":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},")":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}},"m":{"docs":{},"e":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}},"e":{"docs":{"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.07633587786259542}},"r":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"i":{"docs":{},"f":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.013513513513513514},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.015625},"documents/certificates.html":{"ref":"documents/certificates.html","tf":10.213740458015268}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"s":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}},"p":{"docs":{},"d":{"docs":{},"f":{"docs":{},")":{"docs":{"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.007633587786259542}}}}}}},"\"":{"docs":{"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.007633587786259542}}}}}}}},"l":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"e":{"docs":{},"=":{"docs":{},"'":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"t":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"s":{"docs":{},"=":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":10.041666666666666},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.05},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.008602150537634409}}}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"a":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"o":{"docs":{},"m":{"1":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},"4":{"docs":{},")":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815}}}},"6":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.01680672268907563},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"i":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"r":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}}},"u":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}},";":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}},"r":{"docs":{},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}},"e":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},"d":{"docs":{},"!":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},",":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}}}}}},"x":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"i":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.023809523809523808},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},"o":{"docs":{},"n":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}}}}},"s":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"e":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},"m":{"docs":{},"u":{"docs":{},"n":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}}}}},"a":{"docs":{"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.010752688172043012},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0410958904109589},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.011307420494699646},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},":":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},":":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},")":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"o":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}},"l":{"docs":{},"i":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},";":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}}}}}}},"n":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.04430379746835443},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.0625},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.025495750708215296},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.02976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.026239067055393587},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.03459119496855346},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.033734939759036145},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.01904761904761905},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.02100840336134454},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.042105263157894736},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.036585365853658534},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.040697674418604654},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.015189873417721518},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.03134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.043478260869565216},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.02304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.01953125},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.013513513513513514},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.010178117048346057},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.052083333333333336},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.03773584905660377},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.011235955056179775},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0392156862745098},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.023809523809523808},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.05154639175257732},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":2.5384615384615383},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.692439862542955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}},".":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},".":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}}},".":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.018867924528301886}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875}}},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}},",":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}}}},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}},"o":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.019830028328611898},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.020833333333333332},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.02040816326530612},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.015723270440251572},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.01927710843373494},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112}}},",":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}}},",":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}},"o":{"docs":{},"r":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476}}}}}}},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}},"c":{"docs":{},"b":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}},"p":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}},"t":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},"l":{"docs":{},"i":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"s":{"docs":{},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809}}},"o":{"docs":{},"r":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.01904761904761905},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0215633423180593},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.011976047904191617},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01366120218579235}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}},"(":{"0":{"docs":{},"x":{"3":{"3":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"5":{"5":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}},"docs":{},"c":{"docs":{},"c":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}},"f":{"0":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"docs":{}}}},"1":{"2":{"0":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"3":{"docs":{},")":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}},"docs":{}},"docs":{}},"2":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"4":{"0":{"9":{"6":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"_":{"docs":{},"i":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},"x":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341}}}}},"o":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.05303030303030303}},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654}}}}}},"i":{"docs":{},"d":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},"r":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.045454545454545456},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}},"s":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}},"n":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776}}}},"i":{"docs":{},"n":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/":{"ref":"tutorials/all/","tf":0.08333333333333333},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.008403361344537815},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/":{"ref":"datasheets/boards/","tf":0.05555555555555555},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"s":{"docs":{},":":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":3.0020366598778003},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.011461318051575931},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176}},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.033707865168539325},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":5.016129032258065},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":5.024590163934426}},".":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.02459016393442623}}},",":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"s":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"x":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.009191176470588236},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"advance/cli.html":{"ref":"advance/cli.html","tf":0.004240282685512367}},"o":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}},"g":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}}},"g":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.011824324324324325},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.012962962962962963},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},":":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}}},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}},"=":{"docs":{},"[":{"docs":{},"'":{"docs":{},"d":{"docs":{},"h":{"docs":{},"c":{"docs":{},"p":{"docs":{},"'":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}},")":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"u":{"docs":{},"s":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}}}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}},"a":{"docs":{},"g":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}},".":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}},"i":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549}}}},",":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}}},"e":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}},"d":{"docs":{},"e":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.024096385542168676},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.01904761904761905},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.02112676056338028},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.016181229773462782},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.014678899082568808},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":3.345872518286311},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0326975476839237},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.02389705882352941},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.011976047904191617},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.010416666666666666},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},":":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"s":{"docs":{},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},":":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}},")":{"docs":{},".":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},"_":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"4":{"docs":{},"_":{"5":{"docs":{},",":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.07317073170731707}}}}}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"i":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825}},"s":{"docs":{},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"r":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"d":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"p":{"docs":{},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"documents/license.html":{"ref":"documents/license.html","tf":0.022900763358778626}},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}},"y":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}}},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"documents/license.html":{"ref":"documents/license.html","tf":0.030534351145038167}}}}}}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}},"n":{"docs":{},"t":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}},")":{"docs":{},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}},"r":{"docs":{},"i":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}},"_":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}},"i":{"docs":{},"n":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}},"k":{"docs":{},"i":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"i":{"docs":{},"l":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.03676470588235294}},"_":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"1":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},"s":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.014545454545454545}}}}}},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.0625},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}},"b":{"docs":{},"o":{"docs":{},"x":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}},"n":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}},"e":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"o":{"docs":{},"s":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.011824324324324325},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.018633540372670808}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}},"n":{"docs":{},"g":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"d":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.032196969696969696},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.0321285140562249},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.006535947712418301},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}},"=":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"6":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"7":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"docs":{}},"s":{"docs":{},",":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},",":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},":":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}},"c":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}},"r":{"1":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},"_":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.022857142857142857}}}}}}}}}}}}}},"2":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}},"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.011976047904191617},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.033112582781456956},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.017142857142857144}},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}}},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.019867549668874173},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"1":{"2":{"3":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},"[":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"'":{"docs":{},"x":{"0":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}},"docs":{}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.038461538461538464}},"e":{"docs":{},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},".":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"t":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},")":{"docs":{},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}},"i":{"docs":{},"p":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825}}}}},"r":{"1":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}},"2":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943}}}},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}},"o":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}}}}}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},".":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"g":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}}}},"l":{"docs":{},"i":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":5.026148409893993}},"c":{"docs":{},"k":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.014678899082568808},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.014326647564469915},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.014084507042253521},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.025078369905956112},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.011824324324324325},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.030927835051546393},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.038922155688622756},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.018633540372670808},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.024390243902439025},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.008445945945945946},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.03125},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}}},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"/":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"_":{"docs":{},"c":{"docs":{},"b":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"/":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}},"p":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},",":{"docs":{"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}}}}}}},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},"x":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.013477088948787063},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0220125786163522},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.17647058823529413},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.01818181818181818},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01092896174863388}},",":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},")":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"'":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"/":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"u":{"docs":{},"s":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}}},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}}}}},"u":{"docs":{},"d":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.07142857142857142}},".":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517}}}}},"c":{"docs":{},"k":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.013513513513513514},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"(":{"docs":{},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}},":":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}},"k":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},"p":{"1":{"1":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}},"docs":{}},"docs":{}}}}},"r":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.022018348623853212},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.011824324324324325},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.020080321285140562},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.009398496240601503},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.008146639511201629},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.005555555555555556},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.011428571428571429},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.007481296758104738},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.033707865168539325},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.021505376344086023},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},".":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}}}}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},".":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"1":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}},"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"1":{"2":{"8":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.021505376344086023}},"i":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}},"c":{"8":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0225},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}}},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.020066889632107024},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.014634146341463415},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.021929824561403508},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.021834061135371178},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.022222222222222223},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}},"_":{"docs":{},"v":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},".":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}}},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":5.040983606557377},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}}}}}},"t":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}},"t":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.06756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.012605042016806723},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512}},"+":{"docs":{},"d":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}},"_":{"docs":{},"c":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},".":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"/":{"docs":{},"c":{"docs":{},"+":{"docs":{},"+":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761}}}}}},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.024390243902439025},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789}}}},".":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"m":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}},"_":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":10.022222222222222}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"s":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}},"e":{"docs":{},":":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}},"x":{"docs":{},"p":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"1":{"0":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}},"docs":{}},"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}}},"i":{"docs":{},":":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}},"q":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}}}}}}}}}},"d":{"docs":{},"c":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"p":{"docs":{},"u":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667}},",":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.012618296529968454},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},"'":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}},"=":{"1":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"3":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"docs":{}}},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.019762845849802372}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},"[":{"1":{"6":{"docs":{},":":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},"'":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"'":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"u":{"docs":{},"m":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"s":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}},":":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"b":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}}}},"k":{"docs":{},"i":{"docs":{},"t":{"docs":{"products.html":{"ref":"products.html","tf":0.03333333333333333},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516}}},"n":{"docs":{},"d":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}},"b":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633}}},"p":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705}}}},"y":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.017045454545454544},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.011976047904191617},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.009259259259259259},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.02766798418972332},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.02493765586034913}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"u":{"docs":{},"p":{"docs":{},"t":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}}}}}}}}}},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.011627906976744186},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},"=":{"docs":{},"'":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.02185792349726776}},",":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}}},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}}}}}}},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}},"p":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"n":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"_":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},"s":{"docs":{},"[":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}},"]":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"b":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}},"l":{"0":{"1":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":10.129032258064516},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":2.5703125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.04580152671755725}},"/":{"docs":{},"w":{"0":{"1":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}},"docs":{}},"docs":{}}},",":{"docs":{"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},":":{"docs":{"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516}}},"'":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}}}},"4":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":10.126984126984127},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},",":{"docs":{"datasheets/oem/":{"ref":"datasheets/oem/","tf":0.07692307692307693},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}}},":":{"docs":{"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872}}}},"docs":{}},"7":{"6":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}},"g":{"docs":{},"n":{"docs":{},"s":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.027777777777777776}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}}}}}}}}}}},"docs":{}},"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}},"i":{"docs":{"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},"p":{"docs":{},"o":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}},"n":{"docs":{},"k":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"u":{"docs":{},"x":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},".":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},",":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"o":{"docs":{},"s":{"docs":{},")":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"e":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},")":{"docs":{},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"g":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"b":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.02112676056338028},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.014678899082568808},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":5.064102564102564},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.09090909090909091},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.006002400960384154},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.04081632653061224},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.008595988538681949},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.030927835051546393},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":1.7233676975945016},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.0136986301369863},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},"/":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"s":{"docs":{},"q":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}},"y":{"docs":{},".":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},"\"":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},";":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}},"'":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}}},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}},"k":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}}},"_":{"docs":{},"a":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"s":{"2":{"docs":{},"h":{"docs":{},"h":{"1":{"2":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0106951871657754},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809}},"p":{"docs":{},"i":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0053475935828877},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}},")":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}}},"docs":{}},"docs":{}}}},"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},"e":{"docs":{},"n":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},".":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.017191977077363897}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}},"k":{"docs":{},"e":{"docs":{},":":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.016172506738544475},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.011976047904191617},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.023809523809523808},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012}},"w":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506}}}}}}},"v":{"docs":{},"e":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},"f":{"docs":{},"e":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"documents/license.html":{"ref":"documents/license.html","tf":10.022900763358779}}},"c":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}},"e":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}},"l":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":10.036827195467422},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":5.002976190476191},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.019230769230769232},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.014778325123152709},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":10.018867924528301},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":5.033707865168539},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":10.043668122270743},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":5.008},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.04580152671755725}}},"y":{"4":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.03273809523809524},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.064},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}},",":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008}}},":":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008}}}},"docs":{},",":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/development/":{"ref":"datasheets/development/","tf":0.05555555555555555},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236}}},"!":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}},"\"":{"docs":{},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0111731843575419}}}}},"s":{"docs":{},".":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}}},"'":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}}},"'":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"r":{"docs":{},"a":{"docs":{"products.html":{"ref":"products.html","tf":0.02},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.014164305949008499},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.017045454545454544},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.023809523809523808},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.008403361344537815},"tutorials/lora/":{"ref":"tutorials/lora/","tf":5.076923076923077},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":2.5567375886524824},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.019704433497536946},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.02185792349726776},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":2.5198511166253104},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.04716981132075472},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.033707865168539325},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":10.033986928104575},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"/":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747}}}}}}}}},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}}}}}},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}}}}}}}}}}}},")":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}},",":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":10.046511627906977},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.011363636363636364},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.028846153846153848},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":5.019704433497537},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":5.016393442622951},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.018300653594771243},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.03225806451612903},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.031746031746031744}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}},"a":{"docs":{},"s":{"9":{"2":{"3":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"docs":{}},"docs":{}},"docs":{}},"u":{"9":{"1":{"5":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"docs":{}},"docs":{}},"docs":{}},"b":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},"d":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}}}}}}}}}}}}}},"l":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}}}}}}}},"e":{"docs":{},"u":{"8":{"6":{"8":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"(":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"r":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"a":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}}},"a":{"docs":{},"b":{"docs":{},"p":{"docs":{},",":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{},"t":{"docs":{},"o":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}},"u":{"docs":{},"s":{"9":{"1":{"5":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}}},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"_":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"[":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"b":{"docs":{},"w":{"docs":{},"_":{"1":{"2":{"5":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"w":{"docs":{},"_":{"1":{"2":{"5":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"docs":{}},"docs":{}},"2":{"5":{"0":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"docs":{},"k":{"docs":{},"h":{"docs":{},"z":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"docs":{}},"docs":{}},"docs":{}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"=":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"x":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"c":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"4":{"docs":{},"_":{"5":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"6":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}},"7":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"8":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"[":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"4":{"docs":{},"_":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"(":{"8":{"6":{"8":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"[":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.0032679738562091504}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}},"n":{"docs":{},"v":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"_":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"a":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"p":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"[":{"docs":{},"p":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"[":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"4":{"docs":{},"_":{"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"1":{"2":{"7":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"(":{"7":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"[":{"docs":{},"s":{"docs":{},"f":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}}}},"t":{"docs":{},"x":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"e":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}}},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}}}}},"b":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"v":{"docs":{},"(":{"2":{"5":{"6":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"docs":{}},"docs":{}},"6":{"4":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}},"docs":{}},"docs":{}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}}},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},")":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}}}},"t":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},")":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":2.50709219858156}}},"e":{"docs":{},"u":{"8":{"6":{"8":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.014814814814814815},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.02040816326530612},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}},"=":{"2":{"0":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}},"docs":{}},"docs":{}}}}}},"l":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.041666666666666664},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.03333333333333333},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}}}}}},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}}},"k":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.046153846153846156}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"a":{"docs":{},"c":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},"=":{"1":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},"docs":{}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666}}}},":":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}},"g":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"i":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"=":{"docs":{},"(":{"docs":{},"'":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}}}},".":{"docs":{"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728}}}},"c":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.03333333333333333},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01818181818181818}}}}}}}}},"n":{"docs":{},"g":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}},"s":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"e":{"docs":{},"/":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}}}}}}}}}}}}}}}},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.015810276679841896}}}}},"o":{"docs":{},"k":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}},"u":{"docs":{},"p":{"docs":{"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"s":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}},"p":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.022653721682847898},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},")":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},".":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}},",":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},"/":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.006756756756756757}}}}}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}}}}}},"a":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.005399568034557235},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},")":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}}},"w":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.007575757575757576},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"e":{"docs":{},"r":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.01282051282051282}},",":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"s":{"docs":{},"t":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"s":{"docs":{},"e":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"t":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"t":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0220125786163522},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.016867469879518072},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/lte/":{"ref":"tutorials/lte/","tf":5.05},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.04945054945054945},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.059322033898305086},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.011111111111111112},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":10.04516129032258},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.020689655172413793},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.019867549668874173},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},".":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495}}},"*":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"=":{"1":{"3":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"docs":{}},"docs":{}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}},"*":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"3":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"docs":{}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},":":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},":":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"*":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}}}}}}},"+":{"docs":{},"c":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"=":{"0":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}},"1":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}},"docs":{}}}}},"g":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"=":{"1":{"docs":{},",":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"p":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"b":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"d":{"docs":{},"s":{"docs":{},"p":{"docs":{},"\"":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"s":{"docs":{},"n":{"docs":{},"=":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}},"docs":{}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"?":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}},"(":{"docs":{},")":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}}},"r":{"3":{"2":{"9":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"0":{"1":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}},"(":{"docs":{},"p":{"docs":{},"y":{"docs":{},")":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}}}}}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}},"e":{"docs":{},"d":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.012844036697247707},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.010899182561307902},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":5.070422535211268},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549}},")":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577}},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}}}}}},"(":{"0":{"docs":{},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"1":{"docs":{},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"docs":{}}},"f":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"v":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"d":{"docs":{"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.007984031936127744},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.014256619144602852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},".":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}},"s":{"docs":{},"s":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}},")":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}},"g":{"docs":{},"a":{"docs":{},"c":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"n":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872}}},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},")":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}}},"(":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}},"'":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"'":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}}}},"a":{"docs":{},"b":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}},"e":{"docs":{},"l":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.010126582278481013},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},".":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}},"r":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.015384615384615385},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"e":{"docs":{},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"'":{"docs":{},"}":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227}},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}}}}},"r":{"docs":{},"g":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"s":{"docs":{},"t":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00522875816993464},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"g":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.013333333333333334}}}}}}}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"c":{"docs":{},"k":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"p":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}},"\"":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.013071895424836602},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629}}},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}},")":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}},"s":{"docs":{},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},":":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"\"":{"docs":{},")":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.01445466491458607},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.025}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"=":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},".":{"docs":{},".":{"docs":{},"/":{"docs":{},".":{"docs":{},".":{"docs":{},"/":{"docs":{},".":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"/":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"l":{"0":{"1":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"d":{"docs":{},"f":{"docs":{},")":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}}}}}}}}}}}},")":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704}}},"s":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"u":{"docs":{},"x":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525}},".":{"docs":{"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.008086253369272238},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809}}}}},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}},"l":{"docs":{},"v":{"docs":{},"m":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}}},"p":{"docs":{},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.005653710247349823}}}}}}},"o":{"docs":{},"e":{"docs":{},"m":{"docs":{"products.html":{"ref":"products.html","tf":0.013333333333333334},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456},"datasheets/oem/":{"ref":"datasheets/oem/","tf":5.153846153846154},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":2.5703125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":2.591666666666667},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"documents/certificates.html":{"ref":"documents/certificates.html","tf":0.015267175572519083}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},",":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"e":{"docs":{},".":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}}},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},":":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}},")":{"docs":{},";":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464}}}}}}},"a":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":5.010804321728691},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}},"a":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.008522727272727272},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":5.019704433497537},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}}}},"_":{"0":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},".":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}},"m":{"docs":{},"v":{"docs":{},"[":{"docs":{},":":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"n":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"c":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.01744186046511628},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.020833333333333332},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"l":{"docs":{},"y":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},",":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476}}}},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}}},")":{"docs":{},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"t":{"docs":{},"o":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"datasheets/boards/deepsleep/":{"ref":"datasheets/boards/deepsleep/","tf":0.0196078431372549},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"e":{"docs":{},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},"w":{"docs":{},"i":{"docs":{},"r":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":5.0175}},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"1":{"0":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}},"docs":{}},"docs":{}}}}}}}},":":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182}}}}}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"_":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}},"g":{"docs":{},"o":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},",":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.007936507936507936},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"g":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"e":{"docs":{},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}}}}},",":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"u":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.003787878787878788},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.022727272727272728},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.014285714285714285},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.037037037037037035},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.006622516556291391},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}},":":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"0":{"docs":{},"x":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"0":{"docs":{},"x":{"docs":{},"f":{"docs":{},"f":{"0":{"0":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"docs":{}},"docs":{}}}}},"docs":{}},"s":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"=":{"docs":{},"[":{"1":{"docs":{},",":{"1":{"docs":{},",":{"1":{"docs":{},",":{"0":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},",":{"1":{"docs":{},",":{"1":{"docs":{},",":{"0":{"docs":{},",":{"0":{"docs":{},",":{"1":{"docs":{},",":{"1":{"docs":{},",":{"1":{"docs":{},"]":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}},".":{"docs":{"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125}}}}},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},".":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385}}},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"v":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.012903225806451613},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.014840989399293287},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"s":{"docs":{},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875}}}},"a":{"docs":{},"l":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}},";":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},",":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"m":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}},"i":{"docs":{},"s":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.010033444816053512},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"e":{"docs":{},"n":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.007339449541284404},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.02100840336134454},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.015789473684210527},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.005319148936170213},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},".":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}},")":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}}}}}},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789}}}}},"m":{"docs":{},"o":{"docs":{},"k":{"docs":{},"o":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"(":{"docs":{},"'":{"docs":{},"/":{"docs":{},"s":{"docs":{},"d":{"docs":{},"/":{"docs":{},"g":{"docs":{},"p":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"m":{"docs":{},"g":{"docs":{},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}},"r":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}},".":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},"\"":{"docs":{},".":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}}},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}},"i":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762}}}},"r":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}}}},"/":{"docs":{},"o":{"docs":{},"n":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}},")":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}},"\"":{"docs":{},")":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"_":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}},".":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.003676470588235294}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.009198423127463863},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.02459016393442623}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},".":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}},"=":{"0":{"docs":{},")":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}},"docs":{}}}}}},".":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},":":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"s":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}},".":{"docs":{},"m":{"docs":{},"k":{"docs":{},"f":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"'":{"docs":{},")":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}}}}}}},"s":{"docs":{},"d":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}},"d":{"docs":{},"u":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"(":{"docs":{},"'":{"docs":{},"/":{"docs":{},"s":{"docs":{},"d":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"/":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.01098901098901099},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.018518518518518517},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.022058823529411766},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.014084507042253521},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}}}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}}},"j":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.02142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.007518796992481203},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.013245033112582781},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.013972055888223553},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.010183299389002037},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.019867549668874173},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.011826544021024968},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.013333333333333334},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.044444444444444446},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.023809523809523808},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.013108614232209739},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.05217391304347826},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541}},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},";":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.015267175572519083},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}},".":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},"'":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},".":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}},"c":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},",":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},"s":{"docs":{},".":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.011461318051575931}}}}},"p":{"docs":{},"i":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}},"l":{"docs":{},"d":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},"e":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}},"w":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}},"n":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889}}}}}}},"k":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},".":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}},"h":{"docs":{},"m":{"docs":{"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"u":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.04285714285714286}},"n":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":2.5166666666666666}}}}}},"x":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},"q":{"docs":{},"u":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.014326647564469915},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},",":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}},"t":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.010183299389002037},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},")":{"docs":{},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},".":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":0.058823529411764705},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}}}}},"l":{"docs":{},"i":{"docs":{"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.010416666666666666},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"a":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222}}}}}}}}}},"b":{"docs":{},"l":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"g":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.03278688524590164}}}}}},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}}}}}}}}}}},"b":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"u":{"docs":{},"s":{"docs":{},"u":{"docs":{"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857}}}}}},"s":{"9":{"1":{"5":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.014164305949008499},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.01488095238095238},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.014577259475218658},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.012578616352201259},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.02650602409638554},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.04819277108433735},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.020833333333333332},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.023809523809523808},"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.035211267605633804},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.02018348623853211},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.04054054054054054},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.02100840336134454},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.021052631578947368},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.03048780487804878},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.013888888888888888},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.019886363636363636},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.012658227848101266},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.027247956403269755},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.008865248226950355},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0106951871657754},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.027777777777777776},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0223463687150838},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.037037037037037035},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.02857142857142857},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.008928571428571428},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.03333333333333333},"tutorials/all/rgbled.html":{"ref":"tutorials/all/rgbled.html","tf":0.028169014084507043},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.014705882352941176},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.007202881152460984},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.011363636363636364},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.04807692307692308},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.02127659574468085},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.014778325123152709},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.01488833746898263},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.013392857142857142},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.02197802197802198},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.0423728813559322},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.028077753779697623},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.018518518518518517},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.015555555555555555},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.012048192771084338},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.011278195488721804},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.023668639053254437},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.013972055888223553},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.015723270440251572},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.010183299389002037},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":0.047619047619047616},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.018518518518518517},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.008905852417302799},"firmwareapi/pycom/network/bluetooth/gatt.html":{"ref":"firmwareapi/pycom/network/bluetooth/gatt.html","tf":0.041666666666666664},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.01241830065359477},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.016209476309226933},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.010752688172043012},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.019762845849802372},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.03678929765886288},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.013140604467805518},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.015772870662460567},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.024390243902439025},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.01951219512195122},"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0234375},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.015384615384615385},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":0.015873015873015872},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.022058823529411766},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.02247191011235955},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.02857142857142857},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.03787878787878788},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.026143790849673203},"advance/cli.html":{"ref":"advance/cli.html","tf":0.011307420494699646},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"b":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.019830028328611898},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.020833333333333332},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.02040816326530612},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0220125786163522},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.016867469879518072},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.022222222222222223},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":3.3585434173669464},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.030141843971631204},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.02027027027027027},"datasheets/boards/pytrack.html":{"ref":"datasheets/boards/pytrack.html","tf":0.02631578947368421},"datasheets/boards/pysense.html":{"ref":"datasheets/boards/pysense.html","tf":0.02631578947368421},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/expansion2.html":{"ref":"datasheets/boards/expansion2.html","tf":0.038461538461538464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"\"":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},".":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},")":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},".":{"docs":{},".":{"docs":{},".":{"docs":{"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}}}},"e":{"docs":{},"r":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.014326647564469915},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}},"e":{"docs":{},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}}},",":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},".":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827}}},"i":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},".":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}}},"d":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}}},";":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},",":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}},"/":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}}}},",":{"docs":{"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}},":":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},":":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456}}}}}}}}},"g":{"docs":{"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"e":{"docs":{},":":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00522875816993464},"advance/cli.html":{"ref":"advance/cli.html","tf":0.012720848056537103}}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127}}}},")":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}},",":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},":":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},".":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":10.008196721311476}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"m":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"f":{"docs":{},"m":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"f":{"docs":{},"m":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"f":{"docs":{},"m":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"m":{"docs":{},"t":{"docs":{},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":10.00187265917603},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}},"s":{"docs":{},"l":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":10.0078125}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.024822695035460994},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"s":{"docs":{"products.html":{"ref":"products.html","tf":0.006666666666666667},"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338}}}}}},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}},"/":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}},":":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"m":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":10.004878048780487}},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},"(":{"7":{"5":{"0":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"docs":{}},"docs":{}},"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"7":{"2":{"0":{"0":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"p":{"docs":{},"u":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}},"m":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}},"g":{"docs":{},"m":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}}}},"m":{"docs":{},"k":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}}}}}}}}},"c":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}},":":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}},".":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}},"p":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.008174386920980926},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.013333333333333334},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.008830022075055188},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.013793103448275862},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.022922636103151862},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0056657223796034},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0058309037900874635},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.004819277108433735},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.006349206349206349},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":5.034722222222222},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.009523809523809525},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.027777777777777776},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.02510460251046025},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.0625},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":5.01063829787234},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.008445945945945946},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":5.020408163265306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":3.3560115190784736},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0064794816414686825},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.013513513513513514},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.014705882352941176},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.07692307692307693},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.010752688172043012},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0392156862745098},"advance/cli.html":{"ref":"advance/cli.html","tf":5.012014134275619},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"e":{"docs":{},",":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"r":{"docs":{},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.008639308855291577}}}}}},";":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}}}},"d":{"docs":{},",":{"docs":{"pytrackpysense/installation/":{"ref":"pytrackpysense/installation/","tf":0.03125}}},".":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"_":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},"=":{"3":{"6":{"0":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"\\":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.020833333333333332},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.02159827213822894},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888}}}}}},"e":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},"s":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"gettingstarted/installation/":{"ref":"gettingstarted/installation/","tf":0.012048192771084338},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.013888888888888888},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.014285714285714285},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.005504587155963303},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.021798365122615803},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.038461538461538464},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.015463917525773196},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}},"o":{"docs":{},"n":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}},",":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}}}}},".":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}}},"\"":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"1":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}}},"2":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"docs":{"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":10.031936127744512}},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"9":{"6":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"b":{"docs":{},"a":{"docs":{},"u":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"=":{"9":{"6":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}},".":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},"docs":{}},"5":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}}}},"docs":{},"[":{"docs":{},"n":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},"[":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872}}}}}}}}}}},"x":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"x":{"docs":{},"_":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"_":{"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744}}}},"docs":{}},"/":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"_":{"1":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809}}},"docs":{}}}}},".":{"docs":{},"f":{"docs":{},"l":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.006289308176100629},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.015625},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.016666666666666666}}}}},"u":{"docs":{},"c":{"docs":{},"p":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.02531645569620253},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.013245033112582781},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.017543859649122806}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403}}},"s":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391}}}}}}},"r":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":10.007936507936508}},"l":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}},":":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"'":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},")":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},",":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}}}}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":10.015151515151516},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"5":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"1":{"1":{"2":{"2":{"3":{"3":{"4":{"4":{"5":{"5":{"6":{"6":{"7":{"7":{"8":{"8":{"9":{"9":{"docs":{},"a":{"docs":{},"a":{"docs":{},"b":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"docs":{},"c":{"0":{"0":{"0":{"0":{"0":{"1":{"0":{"0":{"0":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"1":{"1":{"docs":{},"b":{"0":{"2":{"8":{"2":{"docs":{},"a":{"1":{"8":{"9":{"docs":{},"b":{"7":{"5":{"docs":{},"b":{"0":{"docs":{},"b":{"4":{"docs":{},"d":{"2":{"docs":{},"d":{"8":{"docs":{},"c":{"7":{"docs":{},"f":{"docs":{},"a":{"3":{"8":{"5":{"4":{"8":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"2":{"docs":{},"b":{"7":{"docs":{},"e":{"1":{"5":{"1":{"6":{"2":{"8":{"docs":{},"a":{"docs":{},"e":{"docs":{},"d":{"2":{"docs":{},"a":{"6":{"docs":{},"a":{"docs":{},"b":{"docs":{},"f":{"7":{"1":{"5":{"8":{"8":{"0":{"9":{"docs":{},"c":{"docs":{},"f":{"4":{"docs":{},"f":{"3":{"docs":{},"c":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00261437908496732}}}}}},"docs":{}}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"7":{"0":{"docs":{},"b":{"3":{"docs":{},"d":{"5":{"7":{"docs":{},"e":{"docs":{},"d":{"0":{"0":{"0":{"8":{"docs":{},"c":{"docs":{},"d":{"6":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{},"b":{"5":{"7":{"docs":{},"f":{"3":{"6":{"docs":{},"d":{"8":{"8":{"6":{"9":{"1":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"5":{"docs":{},"e":{"docs":{},"e":{"8":{"6":{"5":{"9":{"3":{"2":{"0":{"1":{"6":{"9":{"docs":{},"a":{"6":{"1":{"docs":{},"c":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"a":{"docs":{},"d":{"docs":{},"a":{"4":{"docs":{},"d":{"docs":{},"a":{"docs":{},"e":{"3":{"docs":{},"a":{"docs":{},"c":{"1":{"2":{"6":{"7":{"6":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}}}},"docs":{}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}}},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}}}}}}},"b":{"docs":{},"'":{"1":{"2":{"3":{"4":{"5":{"docs":{},"'":{"docs":{},")":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"a":{"2":{"docs":{},"b":{"docs":{},"_":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"6":{"4":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}}}},"docs":{}},"docs":{}}}}}}}},"docs":{}},"b":{"2":{"docs":{},"a":{"docs":{},"_":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"6":{"4":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/micropython/ubinascii.html":{"ref":"firmwareapi/micropython/ubinascii.html","tf":0.015151515151515152}}}}}}}}},"docs":{}},"docs":{}}}}}}}},"docs":{}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"u":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"d":{"docs":{},"p":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},"l":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}}},"p":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222}}}},"i":{"docs":{},"d":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.00998003992015968},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},":":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"n":{"docs":{},"t":{"1":{"6":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"docs":{}},"docs":{}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"u":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}},"e":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":10.010752688172044}},".":{"docs":{},"a":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":10.003942181340342}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}}},"b":{"docs":{},"f":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"docs":{}},"docs":{}}}}}},"i":{"docs":{},"g":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}}},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}}},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"3":{"2":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"docs":{}},"8":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.006570302233902759}},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"docs":{}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":10.022222222222222}},".":{"docs":{},"d":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},"s":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},")":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},"f":{"docs":{},"p":{"docs":{},")":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}}}}},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},")":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}}}}}}}}}}}}}}}},"o":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":10.008888888888889}},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}},"d":{"docs":{},"u":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"_":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"w":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}}},"m":{"docs":{},"k":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}},"f":{"docs":{},"s":{"docs":{},"(":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}}}},"m":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"p":{"docs":{},":":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"n":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":10.008695652173913}},".":{"docs":{},"m":{"docs":{},"d":{"5":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"docs":{}}},"s":{"docs":{},"h":{"docs":{},"a":{"1":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"2":{"2":{"4":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"docs":{}},"5":{"6":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"docs":{}},"docs":{}},"3":{"8":{"4":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{},"(":{"docs":{},"[":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/uhashlib.html":{"ref":"firmwareapi/micropython/uhashlib.html","tf":0.008695652173913044}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"✔":{"docs":{"products.html":{"ref":"products.html","tf":0.2866666666666667}}},"n":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"g":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.018633540372670808},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.008368200836820083},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.009404388714733543},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.023076923076923078},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},"n":{"docs":{},"o":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.011461318051575931},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":2.5049627791563274},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872}}}},"m":{"docs":{},"e":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.013513513513513514},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.012422360248447204},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00819672131147541},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0049469964664310955}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},".":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"\"":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}}},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}},"s":{"docs":{},".":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.012195121951219513},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}},"u":{"docs":{},"r":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.01090909090909091}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/":{"ref":"gettingstarted/connection/","tf":0.03125},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.019830028328611898},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.023809523809523808},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.02040816326530612},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.018867924528301886},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.02650602409638554},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.012698412698412698},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.031055900621118012},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.031192660550458717},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.010526315789473684},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.012552301255230125},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.005063291139240506},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.014084507042253521},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.012539184952978056},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.005449591280653951},"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.012422360248447204},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.007407407407407408},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.003740648379052369},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.005256241787122208},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.033707865168539325},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.021505376344086023},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.0196078431372549},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.00997506234413965}},"s":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}}}},"t":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.009216589861751152},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.027777777777777776},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.05813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":5.020057306590258},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.019886363636363636},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.02304147465437788},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.015625},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.007202881152460984},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.014778325123152709},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.016483516483516484},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.01694915254237288},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.006666666666666667},"firmwareapi/pycom/network/":{"ref":"firmwareapi/pycom/network/","tf":10.19047619047619},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.016666666666666666},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.005089058524173028},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00980392156862745},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.006234413965087282},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.010752688172043012},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"docnotes/mesh-networks.html":{"ref":"docnotes/mesh-networks.html","tf":5.117647058823529},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.006329113924050633},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.023255813953488372},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.005681818181818182},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0024937655860349127},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}},"docs":{}}}}}}}}}}},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},"docs":{}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"=":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"w":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"docs":{}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}}}}}}}},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}}},"docs":{}}}}}}}}},"s":{"docs":{},".":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.012658227848101266},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}},",":{"docs":{"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"gettingstarted/registration/":{"ref":"gettingstarted/registration/","tf":0.02631578947368421}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},"[":{"docs":{},"'":{"docs":{},"p":{"docs":{},"w":{"docs":{},"d":{"docs":{},"'":{"docs":{},"]":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667}},"e":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"docs":{}},"]":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"docs":{}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"w":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.02510460251046025},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.016666666666666666},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.02586206896551724},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0056179775280898875},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.009230769230769232},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909},"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"docnotes/introduction.html":{"ref":"docnotes/introduction.html","tf":0.05714285714285714}},"e":{"docs":{},"r":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746}},")":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}},",":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}}}}},"l":{"docs":{},"i":{"docs":{"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541}},"n":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}}}}},")":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}},"x":{"docs":{},"t":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0113314447592068},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.011904761904761904},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.011661807580174927},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.00963855421686747},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/apireference/":{"ref":"pytrackpysense/apireference/","tf":0.045454545454545456},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.003472222222222222},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.0049261083743842365},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"i":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},"l":{"docs":{},"i":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}},"g":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705}}}}}}}},"o":{"docs":{},"w":{"docs":{"gettingstarted/introduction.html":{"ref":"gettingstarted/introduction.html","tf":0.0189873417721519},"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0084985835694051},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.008928571428571428},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.008746355685131196},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.009523809523809525},"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.012422360248447204},"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444},"gettingstarted/programming/":{"ref":"gettingstarted/programming/","tf":0.004761904761904762},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.015384615384615385},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"pybytes/getstarted.html":{"ref":"pybytes/getstarted.html","tf":0.022727272727272728},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.008982035928143712},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}},",":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}},"t":{"docs":{},"e":{"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0026954177897574125},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.017857142857142856},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":10.00909090909091},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.008771929824561403},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.013793103448275862},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.008733624454148471},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.016},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.008888888888888889},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.013793103448275862},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.013245033112582781},"datasheets/oem/w01.html":{"ref":"datasheets/oem/w01.html","tf":0.017543859649122806},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"datasheets/notes.html":{"ref":"datasheets/notes.html","tf":10.007936507936508},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},":":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.005952380952380952},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.0031446540880503146},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677},"gettingstarted/connection/wipy.html":{"ref":"gettingstarted/connection/wipy.html","tf":0.0031746031746031746},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279},"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}},"s":{"docs":{},".":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"datasheets/introduction.html":{"ref":"datasheets/introduction.html","tf":0.045454545454545456}}}},",":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"pybytes/integrations/amazon-iot.html":{"ref":"pybytes/integrations/amazon-iot.html","tf":0.006211180124223602},"documents/license.html":{"ref":"documents/license.html","tf":0.015267175572519083}}},"f":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}},"i":{"docs":{"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888}}}},"h":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}},"a":{"docs":{},"t":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"b":{"docs":{},"l":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}},".":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.006944444444444444},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},",":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},".":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}}}},"d":{"docs":{},"e":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.008595988538681949},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/introduction.html":{"ref":"tutorials/introduction.html","tf":0.013888888888888888},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.018867924528301886},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/l01.html":{"ref":"datasheets/oem/l01.html","tf":0.016129032258064516},"datasheets/oem/l04.html":{"ref":"datasheets/oem/l04.html","tf":0.015873015873015872}},"j":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.007594936708860759},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028}},"s":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"=":{"docs":{},"'":{"docs":{},"g":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}}}}}}}},"n":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.009852216748768473},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.01092896174863388},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/":{"ref":"firmwareapi/pycom/","tf":0.03571428571428571},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00392156862745098},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.004319654427645789},"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.02857142857142857},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.00749063670411985},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"e":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.011976047904191617},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.003937007874015748},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}},".":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762}}},":":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.004878048780487805}}},".":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.003816793893129771},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}},"n":{"docs":{},"e":{"docs":{},"g":{"docs":{"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.004987531172069825}}}}}}}}},"u":{"docs":{},"t":{"docs":{},".":{"docs":{"gettingstarted/connection/lopy.html":{"ref":"gettingstarted/connection/lopy.html","tf":0.0028328611898017},"gettingstarted/connection/lopy4.html":{"ref":"gettingstarted/connection/lopy4.html","tf":0.002976190476190476},"gettingstarted/connection/sipy.html":{"ref":"gettingstarted/connection/sipy.html","tf":0.0029154518950437317},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.0024096385542168677}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},",":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"2":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},")":{"docs":{},":":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.011111111111111112},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.005988023952095809},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.0055147058823529415},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.005681818181818182},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.03571428571428571},"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.011278195488721804},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.013972055888223553},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.006109979633401222},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.004575163398692811},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.004301075268817204},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.009198423127463863},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.022222222222222223},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/gc.html":{"ref":"firmwareapi/micropython/gc.html","tf":0.04878048780487805},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.009363295880149813},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.01951219512195122},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.03225806451612903},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.005376344086021506},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.00819672131147541},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.005988023952095809}},",":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}},".":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}},"s":{"docs":{},".":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714},"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}},"\"":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}},":":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}},";":{"docs":{"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}}}}}},"e":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccservice.html","tf":0.012658227848101266},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}},"b":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602}}},"docs":{"gettingstarted/connection/gpy.html":{"ref":"gettingstarted/connection/gpy.html","tf":0.009433962264150943},"gettingstarted/connection/fipy.html":{"ref":"gettingstarted/connection/fipy.html","tf":0.007228915662650603},"gettingstarted/registration/cellular.html":{"ref":"gettingstarted/registration/cellular.html","tf":0.013888888888888888},"tutorials/lte/":{"ref":"tutorials/lte/","tf":0.05},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":5.02542372881356},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391},"datasheets/oem/g01.html":{"ref":"datasheets/oem/g01.html","tf":0.0136986301369863}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.003992015968063872},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"s":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}},"]":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}}}}}}}},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"s":{"docs":{},"=":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"docs":{}}}}}}}}}},"v":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0035335689045936395}},"m":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}},")":{"docs":{},".":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.008639308855291577}},"_":{"docs":{},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}},"s":{"docs":{},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},":":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}},"f":{"docs":{},"c":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.007407407407407408},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.025}},".":{"docs":{},"m":{"docs":{},"f":{"docs":{},"r":{"docs":{},"c":{"6":{"3":{"0":{"docs":{},"_":{"docs":{},"c":{"docs":{},"m":{"docs":{},"d":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"w":{"docs":{},"k":{"docs":{},"_":{"docs":{},"s":{"docs":{},"w":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00130718954248366}},",":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"s":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}},"t":{"docs":{},"p":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.011834319526627219}},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474}}}}}},"x":{"docs":{},"p":{"docs":{"datasheets/boards/pyscan.html":{"ref":"datasheets/boards/pyscan.html","tf":0.01020408163265306}}}}},".":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602},"pytrackpysense/installation/drivers.html":{"ref":"pytrackpysense/installation/drivers.html","tf":0.007692307692307693},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}},"p":{"docs":{},"i":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282}}}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\\":{"docs":{},"p":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"r":{"docs":{},"\\":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.007905138339920948},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.002150537634408602},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/ujson.html":{"ref":"firmwareapi/micropython/ujson.html","tf":0.022222222222222223}}}}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}}}}}}}}}},"b":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602}},"(":{"docs":{},".":{"docs":{},"g":{"docs":{},"z":{"docs":{},")":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},".":{"docs":{},"g":{"docs":{},"z":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.013071895424836602}}}}}}}},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"u":{"docs":{},"p":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"n":{"docs":{},"v":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/installation/drivers.html":{"ref":"gettingstarted/installation/drivers.html","tf":0.006211180124223602}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"`":{"docs":{"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394}}}}}}}}}}}}}},"p":{"1":{"0":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}},"9":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}}},"docs":{}},"`":{"docs":{},"p":{"1":{"1":{"docs":{},"`":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"4":{"docs":{},"`":{"docs":{},"`":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}}},"docs":{}},"2":{"0":{"docs":{},"`":{"docs":{},"`":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703}}}}},"1":{"docs":{},"`":{"docs":{},"`":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.002702702702702703},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}},",":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"2":{"docs":{},"`":{"docs":{},"`":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}}}},"3":{"docs":{},"`":{"docs":{},"`":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"docs":{}},"4":{"docs":{},"`":{"docs":{},"`":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}}},"docs":{}}}},"‘":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{"gettingstarted/installation/firmwaretool.html":{"ref":"gettingstarted/installation/firmwaretool.html","tf":0.006944444444444444}}}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"'":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}}}}},"/":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.001893939393939394},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.005494505494505495},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"advance/cli.html":{"ref":"advance/cli.html","tf":0.009187279151943463}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.014084507042253521},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},".":{"docs":{"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}},"/":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}},".":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}},"/":{"docs":{"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.018518518518518517}},".":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"z":{"docs":{},"e":{"docs":{},"n":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.010309278350515464}}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"/":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"*":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"b":{"0":{"1":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.014962593516209476}}},"docs":{}}}}}}},"c":{"docs":{},"u":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"y":{"3":{"4":{"3":{"4":{"3":{"1":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827}}}}},"/":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"?":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"+":{"docs":{},"\"":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"?":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"1":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"d":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}},".":{"docs":{"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"/":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"g":{"docs":{},"z":{"docs":{"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"r":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}}}}}}}}}}},"{":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.004801920768307323},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"}":{"docs":{"gettingstarted/programming/micropython.html":{"ref":"gettingstarted/programming/micropython.html","tf":0.007042253521126761},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}},"\"":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"u":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.009433962264150943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}},"h":{"docs":{},"r":{"docs":{},".":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}}}}}}}}}}}}}}}}}}}}}}}},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},",":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}}}}}}}}}}}}}}}},"'":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"'":{"docs":{},":":{"docs":{},"'":{"2":{"6":{"0":{"4":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"p":{"docs":{},"w":{"docs":{},"d":{"docs":{},"'":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"p":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{},"w":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},",":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},",":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},",":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{},",":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},",":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},",":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},",":{"docs":{},"p":{"docs":{},"y":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{},"c":{"docs":{},"b":{"docs":{},",":{"docs":{},"n":{"docs":{},"v":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{},"l":{"docs":{},"p":{"docs":{},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},",":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"f":{"docs":{},"s":{"docs":{},",":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"}":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"1":{"0":{"9":{"5":{"docs":{},"d":{"docs":{},"f":{"8":{"2":{"1":{"3":{"docs":{},"a":{"docs":{},"a":{"docs":{},"c":{"2":{"9":{"8":{"3":{"docs":{},"e":{"docs":{},"f":{"docs":{},"d":{"6":{"8":{"docs":{},"d":{"docs":{},"b":{"docs":{},"a":{"9":{"4":{"2":{"0":{"docs":{},"c":{"8":{"docs":{},"e":{"docs":{},"f":{"docs":{},"c":{"9":{"docs":{},"c":{"7":{"docs":{},"c":{"4":{"docs":{},"a":{"docs":{},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"b":{"docs":{},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"docs":{}}},"docs":{}}},"3":{"5":{"4":{"3":{"4":{"7":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"\"":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"o":{"docs":{},"k":{"docs":{},".":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.02533783783783784},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"!":{"docs":{},"\"":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"b":{"docs":{},"b":{"docs":{},"\"":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}},"%":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}}},"h":{"docs":{},"\"":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.006472491909385114}}}}},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},"\"":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}},"\"":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}}}}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"1":{"docs":{},".":{"1":{"4":{"4":{"docs":{},":":{"8":{"0":{"0":{"0":{"docs":{},"/":{"1":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"b":{"docs":{},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"1":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"b":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"gettingstarted/programming/repl/":{"ref":"gettingstarted/programming/repl/","tf":0.006756756756756757},"datasheets/boards/expansion3.html":{"ref":"datasheets/boards/expansion3.html","tf":0.006756756756756757}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}}},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"\"":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"\"":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"\"":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}},"u":{"docs":{},"b":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.0078125}}}}}}},"i":{"docs":{},"'":{"docs":{},"m":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}},"o":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.002036659877800407}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}}}}}},"p":{"docs":{},"y":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}}}},"c":{"docs":{},"c":{"6":{"9":{"1":{"4":{"docs":{},"a":{"4":{"5":{"7":{"docs":{},"e":{"docs":{},"b":{"4":{"docs":{},"a":{"docs":{},"f":{"8":{"8":{"5":{"5":{"docs":{},"e":{"docs":{},"c":{"0":{"2":{"docs":{},"f":{"6":{"9":{"0":{"9":{"3":{"1":{"6":{"5":{"2":{"6":{"docs":{},"b":{"docs":{},"d":{"docs":{},"d":{"0":{"8":{"docs":{},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"/":{"docs":{},"c":{"docs":{},"u":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754}}}}}}}}}}}}}}}},"s":{"docs":{},"d":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"m":{"docs":{},"g":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.010309278350515464},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}},"r":{"docs":{},"r":{"2":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"m":{"docs":{},"i":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.005067567567567568}},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{"firmwareapi/micropython/":{"ref":"firmwareapi/micropython/","tf":0.014285714285714285}},"\"":{"docs":{},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}},"t":{"docs":{},"r":{"2":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}}}}}},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}}}}}}},"+":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"+":{"docs":{},"\"":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"+":{"docs":{},"\"":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.009523809523809525}}}}}}}}}}}}}}}}},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}},"[":{"1":{"docs":{},"]":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}},"docs":{}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444}}}}},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0024009603841536613}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0032397408207343412}}}}}}}}}},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}}}},"\"":{"docs":{},"\"":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.025}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"m":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},".":{"docs":{"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.011235955056179775}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.002628120893561104}}}}}},"c":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},":":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}}}}}}}}}},"b":{"0":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"1":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"docs":{},"b":{"docs":{},"%":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}}},"b":{"docs":{},"\"":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543}}}}},"f":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}}},"i":{"docs":{},"t":{"docs":{},"f":{"0":{"docs":{},"\"":{"docs":{},":":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}}},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}}}}},"'":{"3":{"1":{"3":{"2":{"3":{"3":{"3":{"4":{"3":{"5":{"docs":{},"'":{"docs":{},"\"":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}},">":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.00946372239747634}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.009615384615384616}}}}}}},"'":{"1":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},"}":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"2":{"3":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}},"docs":{}},"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}},",":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}},"docs":{}}},"1":{"7":{"8":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"2":{"5":{"5":{"docs":{},".":{"2":{"5":{"5":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}},"2":{"5":{"5":{"docs":{},".":{"0":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"6":{"0":{"4":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}},"docs":{}},"docs":{}},"docs":{},"'":{"docs":{"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.015151515151515152}}}},"8":{"docs":{},".":{"8":{"docs":{},".":{"8":{"docs":{},".":{"8":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.022058823529411766},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"'":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"'":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}}}}}},"g":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"t":{"docs":{},"e":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"'":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"'":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"'":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}}},"'":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}},"d":{"docs":{},"e":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827}},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815}}}}}}},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}}}}}}}},"t":{"docs":{},"f":{"8":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"docs":{}}}},"p":{"1":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00273224043715847}}}}}},"8":{"docs":{},"'":{"docs":{},"]":{"docs":{},")":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}}},".":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.017191977077363897}}}}}},"docs":{}},"2":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936}}},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.004761904761904762},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.005390835579514825},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}},"2":{"docs":{},"'":{"docs":{},",":{"docs":{"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.009523809523809525},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.01078167115902965},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.003992015968063872},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936}}}}},"3":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.007874015748031496}}}}}},"docs":{}},"docs":{},"y":{"docs":{},"'":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"p":{"docs":{},"y":{"docs":{},"'":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"'":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0033783783783783786}}}}}}}}}}}}}}},"'":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}},"}":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}}},"m":{"docs":{},"y":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"'":{"docs":{},":":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{},",":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576}}}}}}}}}}}},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"'":{"docs":{"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.0070921985815602835}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"'":{"docs":{"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.00546448087431694}}}}}}}}}}}},"/":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"d":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444}}}},"/":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"w":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}},"b":{"docs":{},"c":{"docs":{},"'":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}}},"t":{"docs":{},"o":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"'":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"{":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{},"{":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{},"{":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},":":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"}":{"docs":{},"}":{"docs":{},"}":{"docs":{},"'":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"i":{"docs":{},"d":{"docs":{},"'":{"docs":{},":":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}}}}}}}},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"{":{"docs":{},":":{"docs":{},"d":{"docs":{},"}":{"docs":{},"'":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588}}}}}}}}}}}}}}}}}}}}}}}},"\\":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.009259259259259259}}}}}},"x":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006}}}}}},"r":{"docs":{},"'":{"docs":{},")":{"docs":{"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931}}}}},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852}}}}}}},"+":{"1":{"4":{"docs":{},"d":{"docs":{},"b":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"docs":{}},"2":{"2":{"docs":{},"d":{"docs":{},"b":{"docs":{},"m":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}},"docs":{}},"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.009708737864077669},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.008021390374331552},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.028716216216216218},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.014705882352941176},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.03787878787878788}},"=":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}},"p":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}}}}},"?":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},"=":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.02912621359223301},"gettingstarted/registration/sigfox.html":{"ref":"gettingstarted/registration/sigfox.html","tf":0.0041841004184100415},"gettingstarted/registration/lora/":{"ref":"gettingstarted/registration/lora/","tf":0.005813953488372093},"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0057306590257879654},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.022727272727272728},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.010638297872340425},"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.01282051282051282},"pytrackpysense/apireference/pytrack.html":{"ref":"pytrackpysense/apireference/pytrack.html","tf":0.0380952380952381},"pytrackpysense/apireference/pysense.html":{"ref":"pytrackpysense/apireference/pysense.html","tf":0.0431266846361186},"pytrackpysense/apireference/pyscan.html":{"ref":"pytrackpysense/apireference/pyscan.html","tf":0.017964071856287425},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.0374331550802139},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.04377880184331797},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0625},"tutorials/all/https.html":{"ref":"tutorials/all/https.html","tf":0.07407407407407407},"tutorials/all/mqtt.html":{"ref":"tutorials/all/mqtt.html","tf":0.01904761904761905},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0625},"tutorials/all/adc.html":{"ref":"tutorials/all/adc.html","tf":0.03571428571428571},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.11904761904761904},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.1025},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0392156862745098},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.09},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.022058823529411766},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.008403361344537815},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.054924242424242424},"tutorials/lora/lora-mac.html":{"ref":"tutorials/lora/lora-mac.html","tf":0.04964539007092199},"tutorials/lora/lorawan-otaa.html":{"ref":"tutorials/lora/lorawan-otaa.html","tf":0.04433497536945813},"tutorials/lora/lorawan-abp.html":{"ref":"tutorials/lora/lorawan-abp.html","tf":0.0546448087431694},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.07692307692307693},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.11320754716981132},"tutorials/lora/rn2483-to-lopy.html":{"ref":"tutorials/lora/rn2483-to-lopy.html","tf":0.02247191011235955},"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.008928571428571428},"tutorials/lte/cat-m1.html":{"ref":"tutorials/lte/cat-m1.html","tf":0.016483516483516484},"tutorials/lte/nb-iot.html":{"ref":"tutorials/lte/nb-iot.html","tf":0.00847457627118644},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"tutorials/pytrack.html":{"ref":"tutorials/pytrack.html","tf":0.05555555555555555},"tutorials/pysense.html":{"ref":"tutorials/pysense.html","tf":0.07407407407407407},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0625},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.01606425702811245},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.014285714285714285},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.009398496240601503},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.01545253863134658},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.016260162601626018},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.01775147928994083},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.013513513513513514},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.007984031936127744},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.018867924528301886},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.020689655172413793},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.005905511811023622},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.010183299389002037},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.017241379310344827},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.020356234096692113},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","tf":0.04716981132075472},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.045714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.018300653594771243},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.014962593516209476},"firmwareapi/pycom/network/lte.html":{"ref":"firmwareapi/pycom/network/lte.html","tf":0.0064516129032258064},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.023715415019762844},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.019438444924406047},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.006688963210702341},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.006309148264984227},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.007317073170731708},"firmwareapi/micropython/ussl.html":{"ref":"firmwareapi/micropython/ussl.html","tf":0.03125},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.008595988538681949},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.01639344262295082},"docnotes/replscript.html":{"ref":"docnotes/replscript.html","tf":0.007575757575757576}},"=":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.0078125},"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.010135135135135136},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.01},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.006666666666666667},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/lora/module-module.html":{"ref":"tutorials/lora/module-module.html","tf":0.009433962264150943},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0057306590257879654}},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}},">":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557},"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.003669724770642202},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.01056338028169014},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.018808777429467086},"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.004962779156327543},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135},"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},">":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0075},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}},">":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/safeboot.html":{"ref":"gettingstarted/programming/safeboot.html","tf":0.020833333333333332},"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253},"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.0670391061452514},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.0069124423963133645},"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.028985507246376812},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.003134796238244514}}},".":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095}}}},"=":{"docs":{"firmwareapi/micropython/sys.html":{"ref":"firmwareapi/micropython/sys.html","tf":0.0031545741324921135}}}},"=":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.009523809523809525},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"[":{"0":{"docs":{},"x":{"1":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"4":{"3":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}},"docs":{}},"docs":{}},"]":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.003942181340341655}}}},"3":{"3":{"0":{"8":{"0":{"docs":{},"]":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"6":{"3":{"8":{"docs":{},"]":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0064794816414686825}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"advance/cli.html":{"ref":"advance/cli.html","tf":0.03816254416961131}},"'":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"'":{"docs":{},",":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.003236245954692557}}}}}}}},"p":{"1":{"7":{"docs":{},"'":{"docs":{},",":{"docs":{"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.017191977077363897}}}}},"docs":{}},"docs":{}}},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"]":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}}}},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"]":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}},"]":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"#":{"docs":{},"]":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.004319654427645789}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"c":{"docs":{},"c":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}}},"[":{"0":{"docs":{},"x":{"4":{"3":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}},"docs":{}},"docs":{}}},"docs":{}},"(":{"0":{"docs":{},"x":{"0":{"0":{"1":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"1":{"0":{"0":{"docs":{},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"w":{"docs":{},"]":{"docs":{},".":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.011235955056179775}}}},"o":{"docs":{},"b":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}}}}},"n":{"docs":{},"/":{"docs":{},"a":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"b":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}},"x":{"docs":{"gettingstarted/programming/examples.html":{"ref":"gettingstarted/programming/examples.html","tf":0.016181229773462782},"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.007352941176470588},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.04727272727272727},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}},"x":{"docs":{},"x":{"docs":{"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943}},"x":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},",":{"docs":{"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.007042253521126761},"pymakr/installation/vscode.html":{"ref":"pymakr/installation/vscode.html","tf":0.006269592476489028},"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}}}},"m":{"docs":{},"l":{"docs":{"pymakr/settings.html":{"ref":"pymakr/settings.html","tf":0.006211180124223602}}}},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.08727272727272728}},"x":{"docs":{},".":{"docs":{},"x":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}}}},"/":{"docs":{},"y":{"docs":{},"/":{"docs":{},"z":{"docs":{"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","tf":0.006622516556291391},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714}}}},".":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}}}},")":{"docs":{"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.0036363636363636364}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},",":{"docs":{"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}}}}}}}},",":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"^":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"pymakr/installation/atom.html":{"ref":"pymakr/installation/atom.html","tf":0.0035211267605633804},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},"q":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.001834862385321101},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/apireference/sleep.html":{"ref":"pytrackpysense/apireference/sleep.html","tf":0.00267379679144385},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0022222222222222222},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/dac.html":{"ref":"firmwareapi/pycom/machine/dac.html","tf":0.007142857142857143},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0018796992481203006},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.005988023952095809},"firmwareapi/pycom/machine/wdt.html":{"ref":"firmwareapi/pycom/machine/wdt.html","tf":0.011494252873563218},"firmwareapi/pycom/machine/sd.html":{"ref":"firmwareapi/pycom/machine/sd.html","tf":0.006896551724137931},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/machine/rmt.html":{"ref":"firmwareapi/pycom/machine/rmt.html","tf":0.004073319755600814},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.001851851851851852},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077},"datasheets/boards/deepsleep/api.html":{"ref":"datasheets/boards/deepsleep/api.html","tf":0.0028653295128939827},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":2.5096153846153846}},"l":{"docs":{},"i":{"docs":{"pytrackpysense/introduction.html":{"ref":"pytrackpysense/introduction.html","tf":0.003703703703703704},"firmwareapi/micropython/ucrypto.html":{"ref":"firmwareapi/micropython/ucrypto.html","tf":0.010752688172043012},"pybytes/connect/":{"ref":"pybytes/connect/","tf":0.020618556701030927},"pybytes/connect/quick.html":{"ref":"pybytes/connect/quick.html","tf":0.019230769230769232},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}}}}}},"t":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.013157894736842105},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.013100436681222707},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.013333333333333334}}}}}}},"t":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}},"`":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"tutorials/all/modbus.html":{"ref":"tutorials/all/modbus.html","tf":0.001838235294117647}}}}}}}},"o":{"docs":{},"t":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}},"e":{"docs":{},"u":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.0018726591760299626}},"e":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}},",":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/notes.html":{"ref":"firmwareapi/notes.html","tf":0.00909090909090909}}},".":{"docs":{"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}}}},"r":{"docs":{},"i":{"docs":{"firmwareapi/micropython/utime.html":{"ref":"firmwareapi/micropython/utime.html","tf":0.0024390243902439024}}}}}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},",":{"docs":{"firmwareapi/micropython/array.html":{"ref":"firmwareapi/micropython/array.html","tf":0.03076923076923077},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.01639344262295082},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}},"]":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0007067137809187279}}}},"|":{"docs":{"gettingstarted/programming/first-project.html":{"ref":"gettingstarted/programming/first-project.html","tf":0.009174311926605505},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.005},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.058823529411764705},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","tf":0.005714285714285714},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.01576872536136662},"firmwareapi/micropython/select.html":{"ref":"firmwareapi/micropython/select.html","tf":0.007633587786259542}},"=":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}},"$":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907},"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842},"gettingstarted/programming/ftp.html":{"ref":"gettingstarted/programming/ftp.html","tf":0.006097560975609756},"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.008865248226950355},"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"advance/downgrade.html":{"ref":"advance/downgrade.html","tf":0.006535947712418301},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0028268551236749115}}}}}}},"i":{"docs":{},"d":{"docs":{},"f":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"y":{"docs":{},"/":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"/":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.012468827930174564}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.007481296758104738}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\\":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.008403361344537815}},".":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}},"n":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/aws.html":{"ref":"tutorials/all/aws.html","tf":0.0016891891891891893}}}}}}},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"+":{"docs":{},"c":{"docs":{},"g":{"docs":{},"s":{"docs":{},"n":{"docs":{},":":{"docs":{"tutorials/lte/imei.html":{"ref":"tutorials/lte/imei.html","tf":0.014492753623188406}}}}}}}}}}}},"~":{"docs":{},"/":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"r":{"docs":{},"c":{"docs":{"gettingstarted/programming/repl/serial.html":{"ref":"gettingstarted/programming/repl/serial.html","tf":0.004201680672268907}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"m":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"m":{"docs":{},"k":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}},"r":{"docs":{},"c":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"r":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"/":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"gettingstarted/programming/repl/telnet.html":{"ref":"gettingstarted/programming/repl/telnet.html","tf":0.005263157894736842}}}},"%":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.026143790849673203},"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.012578616352201259},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/pycom.html":{"ref":"firmwareapi/pycom/pycom.html","tf":0.0021598272138228943},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}},"s":{"docs":{},"\"":{"docs":{"gettingstarted/registration/lora/ttn.html":{"ref":"gettingstarted/registration/lora/ttn.html","tf":0.0028653295128939827},"gettingstarted/registration/lora/senet.html":{"ref":"gettingstarted/registration/lora/senet.html","tf":0.002840909090909091},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797}}},"'":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}},"x":{"docs":{},"'":{"docs":{"tutorials/all/ble.html":{"ref":"tutorials/all/ble.html","tf":0.00390625},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257}}}},"d":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}},"'":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},"s":{"docs":{},":":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.0024813895781637717}}}}},"f":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.0196078431372549},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.009433962264150943}}}},"—":{"docs":{"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}}}}}}}},"“":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"=":{"docs":{},"/":{"docs":{},"u":{"docs":{},"s":{"docs":{},"r":{"docs":{},"/":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"2":{"docs":{},".":{"7":{"docs":{},"”":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"”":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"x":{"docs":{},"\"":{"docs":{"gettingstarted/troubleshooting-guide.html":{"ref":"gettingstarted/troubleshooting-guide.html","tf":0.002531645569620253}}}},"a":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{},"”":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"firmwareapi/introduction.html":{"ref":"firmwareapi/introduction.html","tf":0.00684931506849315}}}}}}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"”":{"docs":{},")":{"docs":{},",":{"docs":{"documents/license.html":{"ref":"documents/license.html","tf":0.007633587786259542}}}}}}}}}}}}}},"}":{"docs":{"pymakr/toolsfeatures.html":{"ref":"pymakr/toolsfeatures.html","tf":0.0027247956403269754},"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.002304147465437788},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335},"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492},"pybytes/connect/flash.html":{"ref":"pybytes/connect/flash.html","tf":0.005154639175257732}},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.0012004801920768306}}},")":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}}},"?":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}},"!":{"docs":{},"?":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0017730496453900709}}}},"?":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}}},"z":{"docs":{"advance/encryption.html":{"ref":"advance/encryption.html","tf":0.0024937655860349127}},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418}}}}}},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{"tutorials/lora/":{"ref":"tutorials/lora/","tf":0.009615384615384616}}},",":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}}},"r":{"docs":{},"o":{"docs":{"firmwareapi/pycom/machine/":{"ref":"firmwareapi/pycom/machine/","tf":0.0044444444444444444},"firmwareapi/micropython/usocket.html":{"ref":"firmwareapi/micropython/usocket.html","tf":0.003745318352059925}},".":{"docs":{"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}},")":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.004464285714285714}},"s":{"docs":{},":":{"docs":{"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563}}}}}}},"i":{"docs":{},"p":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0010799136069114472},"datasheets/oem/l01_reference.html":{"ref":"datasheets/oem/l01_reference.html","tf":0.0078125},"datasheets/oem/universal_reference.html":{"ref":"datasheets/oem/universal_reference.html","tf":0.008333333333333333}},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/builtin.html":{"ref":"firmwareapi/micropython/builtin.html","tf":0.011764705882352941}}}}}},"s":{"docs":{},"p":{"0":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"1":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.0021598272138228943}}},"docs":{}}},",":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.011111111111111112}}},".":{"docs":{"firmwareapi/micropython/cmath.html":{"ref":"firmwareapi/micropython/cmath.html","tf":0.07777777777777778}}}},"–":{"docs":{"pytrackpysense/installation/firmware.html":{"ref":"pytrackpysense/installation/firmware.html","tf":0.0035460992907801418},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.008888888888888889}}},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"p":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"_":{"docs":{"pytrackpysense/installation/libraries.html":{"ref":"pytrackpysense/installation/libraries.html","tf":0.00641025641025641}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"_":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.007444168734491315}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"tutorials/lora/lora-mac-nano-gateway.html":{"ref":"tutorials/lora/lora-mac-nano-gateway.html","tf":0.009925558312655087}}}}}}}}}}}}}}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"_":{"docs":{},"_":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/i2c.html":{"ref":"tutorials/all/i2c.html","tf":0.004761904761904762},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},")":{"docs":{},":":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"_":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{"tutorials/all/timers.html":{"ref":"tutorials/all/timers.html","tf":0.006535947712418301},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.0031446540880503146}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"b":{"docs":{},"_":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0021201413427561835}}}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.05},"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":10.009230769230768},"pybytes/dashboard.html":{"ref":"pybytes/dashboard.html","tf":0.0029940119760479044}},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.006153846153846154}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},",":{"docs":{"tutorials/all/threading.html":{"ref":"tutorials/all/threading.html","tf":0.016666666666666666},"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},",":{"docs":{"tutorials/pyscan.html":{"ref":"tutorials/pyscan.html","tf":0.0125}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"docs":{},"[":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"firmwareapi/micropython/_thread.html":{"ref":"firmwareapi/micropython/_thread.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}},"*":{"docs":{"tutorials/all/repl.html":{"ref":"tutorials/all/repl.html","tf":0.00558659217877095},"tutorials/all/owd.html":{"ref":"tutorials/all/owd.html","tf":0.0025},"tutorials/all/rmt.html":{"ref":"tutorials/all/rmt.html","tf":0.00946969696969697},"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.004016064257028112},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.004415011037527594},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.001272264631043257},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00196078431372549},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/micropython.html":{"ref":"firmwareapi/micropython/micropython.html","tf":0.0033444816053511705},"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/math.html":{"ref":"firmwareapi/micropython/math.html","tf":0.007272727272727273},"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},",":{"docs":{"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.005639097744360902},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874}}},".":{"docs":{"firmwareapi/micropython/uctypes.html":{"ref":"firmwareapi/micropython/uctypes.html","tf":0.001314060446780552}}},"?":{"docs":{"firmwareapi/micropython/ure.html":{"ref":"firmwareapi/micropython/ure.html","tf":0.007936507936507936}}},"*":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}},"*":{"docs":{},"*":{"docs":{"datasheets/development/wipy2.html":{"ref":"datasheets/development/wipy2.html","tf":0.0043859649122807015},"datasheets/development/wipy3.html":{"ref":"datasheets/development/wipy3.html","tf":0.006896551724137931},"datasheets/development/lopy.html":{"ref":"datasheets/development/lopy.html","tf":0.004366812227074236},"datasheets/development/lopy4.html":{"ref":"datasheets/development/lopy4.html","tf":0.008},"datasheets/development/sipy.html":{"ref":"datasheets/development/sipy.html","tf":0.0044444444444444444},"datasheets/development/gpy.html":{"ref":"datasheets/development/gpy.html","tf":0.006896551724137931},"datasheets/development/fipy.html":{"ref":"datasheets/development/fipy.html","tf":0.006622516556291391}}}},"e":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"advance/cli.html":{"ref":"advance/cli.html","tf":0.0014134275618374558}}}}}}}}}}},"!":{"docs":{},"=":{"docs":{"tutorials/all/wlan.html":{"ref":"tutorials/all/wlan.html","tf":0.004608294930875576},"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}},".":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}},",":{"docs":{"firmwareapi/pycom/machine/adc.html":{"ref":"firmwareapi/pycom/machine/adc.html","tf":0.008032128514056224},"firmwareapi/pycom/machine/i2c.html":{"ref":"firmwareapi/pycom/machine/i2c.html","tf":0.0037593984962406013},"firmwareapi/pycom/machine/pin.html":{"ref":"firmwareapi/pycom/machine/pin.html","tf":0.002207505518763797},"firmwareapi/pycom/machine/pwm.html":{"ref":"firmwareapi/pycom/machine/pwm.html","tf":0.008130081300813009},"firmwareapi/pycom/machine/rtc.html":{"ref":"firmwareapi/pycom/machine/rtc.html","tf":0.005917159763313609},"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.008108108108108109},"firmwareapi/pycom/machine/uart.html":{"ref":"firmwareapi/pycom/machine/uart.html","tf":0.001996007984031936},"firmwareapi/pycom/machine/timer.html":{"ref":"firmwareapi/pycom/machine/timer.html","tf":0.006289308176100629},"firmwareapi/pycom/machine/can.html":{"ref":"firmwareapi/pycom/machine/can.html","tf":0.001968503937007874},"firmwareapi/pycom/network/wlan.html":{"ref":"firmwareapi/pycom/network/wlan.html","tf":0.003703703703703704},"firmwareapi/pycom/network/server.html":{"ref":"firmwareapi/pycom/network/server.html","tf":0.008620689655172414},"firmwareapi/pycom/network/bluetooth/":{"ref":"firmwareapi/pycom/network/bluetooth/","tf":0.002544529262086514},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"ref":"firmwareapi/pycom/network/bluetooth/gattsservice.html","tf":0.008771929824561403},"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183},"firmwareapi/pycom/network/sigfox.html":{"ref":"firmwareapi/pycom/network/sigfox.html","tf":0.0012468827930174563},"firmwareapi/pycom/aes.html":{"ref":"firmwareapi/pycom/aes.html","tf":0.003952569169960474},"firmwareapi/micropython/uos.html":{"ref":"firmwareapi/micropython/uos.html","tf":0.0044444444444444444},"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541},"docnotes/syntax.html":{"ref":"docnotes/syntax.html","tf":0.00546448087431694}},"\"":{"docs":{},"\"":{"docs":{},")":{"docs":{"tutorials/all/pir.html":{"ref":"tutorials/all/pir.html","tf":0.0033333333333333335}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},".":{"docs":{},"e":{"docs":{},"u":{"8":{"6":{"8":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"=":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"firmwareapi/pycom/network/lora.html":{"ref":"firmwareapi/pycom/network/lora.html","tf":0.00065359477124183}}}}}}}}}}}}}}}},"]":{"docs":{},",":{"docs":{"tutorials/all/ota.html":{"ref":"tutorials/all/ota.html","tf":0.003601440576230492}}}},"​":{"docs":{"tutorials/sigfox.html":{"ref":"tutorials/sigfox.html","tf":0.022321428571428572}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{"pybytes/introduction.html":{"ref":"pybytes/introduction.html","tf":0.007352941176470588}}}}}}}},"a":{"docs":{},"w":{"docs":{"pybytes/integrations/":{"ref":"pybytes/integrations/","tf":0.03571428571428571}}}}},":":{"docs":{"tutorials/lte/firmware.html":{"ref":"tutorials/lte/firmware.html","tf":0.017278617710583154},"advance/cli.html":{"ref":"advance/cli.html","tf":0.0077738515901060075}}},"@":{"docs":{"firmwareapi/pycom/machine/spi.html":{"ref":"firmwareapi/pycom/machine/spi.html","tf":0.005405405405405406}},",":{"docs":{"firmwareapi/micropython/ustruct.html":{"ref":"firmwareapi/micropython/ustruct.html","tf":0.00819672131147541}}}},"→":{"docs":{"pybytes/connect/sigfox/":{"ref":"pybytes/connect/sigfox/","tf":0.0449438202247191},"pybytes/connect/sigfox/devkit.html":{"ref":"pybytes/connect/sigfox/devkit.html","tf":0.016129032258064516},"pybytes/connect/sigfox/custom.html":{"ref":"pybytes/connect/sigfox/custom.html","tf":0.01639344262295082}}}},"length":23175},"corpusTokens":["!.","!=","\"","\"!\"","\"!bb\"","\"!bb%ds\"","\"!bh\"","\"\"\"","\")","\")[1]","\"+net_to_use+\"","\"+self.basic+\"\\r\\n\\r\\n\")","\"+str(return_code))","\"...","\"/dev/cu.usbseri","\"/sd/appimg.bin\"","\"1.0.1b\"","\"1095df8213aac2983efd68dba9420c8efc9c7c4a\"","\"354347xxxxxxxxx\"\\r\\n\\r\\nok.","\">","\"accepted\":","\"add","\"address\":","\"arr\":","\"arr2\":","\"b'3132333435'\"","\"b0\":","\"b1\":","\"bb%ds\"","\"bbb\"","\"bf\"),","\"big\").","\"bitf0\":","\"bitness\"","\"ccc6914a457eb4af8855ec02f6909316526bdd08\"","\"connect","\"copyright\",","\"credits\"","\"deep","\"delete\":","\"deltalistener\"","\"descriptor\"","\"devic","\"dst_path\":","\"eras","\"feed\"","\"field_name\":","\"firmware\":","\"flash\"","\"flash/changed_file.py\",","\"flash/lib/new_lib.py\",","\"flash/old_file.py\",","\"flash/other_old_file.py\"","\"forc","\"foreign","\"forever\".","\"hash\":","\"heartbeat\"","\"hello","\"hello,","\"help\",","\"help()\"","\"host\"","\"http://192.168.1.144:8000/1.0.1b/flash/changed_file.py\",","\"http://192.168.1.144:8000/1.0.1b/flash/lib/new_lib.py\",","\"http://192.168.1.144:8000/firmware_1.0.1b.bin\",","\"i'm","\"idle\"","\"io.adafruit.com\",user=\"your_username\",","\"license\"","\"mi","\"micro","\"micro\",","\"micropython\"","\"new\"","\"new\":","\"old\"","\"over","\"password\":","\"paste_your_serial_port_here\",","\"ptr\":","\"ptr2\":","\"pybyt","\"python\",","\"rb\")","\"recovery\"","\"rejected\":","\"safe","\"scripts\"","\"secur","\"shadowecho\"","\"shadowupdater\"","\"special\"","\"stall\"","\"sub\":","\"sync_folder\":","\"these","\"timeout\":","\"tradit","\"update\":","\"url\":","\"username\":","\"version\":","\"wifipassword\"),","#","#!/usr/bin/env","##","#################","##################","#######################","########################","#(should","#):","#0","#client_id","#config","#conn_disconn_timeout","#connect","#f.write(\"{}","#flag","#from","#mqtt_oper_timeout","#pi","#thing_nam","$","$idf_path/components/esptool_py/esptool/espefuse.pi","$idf_path/components/esptool_py/esptool/espsecure.pi","$idf_path/components/esptool_py/esptool/esptool.pi","$pycom","$user","%","%d","%d'","%ds:","%f","%s\"","%s'","%x'","&","'","'',","'':","''},","'.join('{:d}'.format(x)","'/flash/cert/aws_client.cert'","'/flash/cert/aws_private.key'","'/flash/cert/aws_root.ca'","'/path/to/catm1","'/path/to/updater.elf')","'/sd')","'/sd/updater.elf')","'10.0.0.1')},","'10.0.0.1',","'123')","'192.168.0.1'))","'192.168.0.1',","'192.168.178.1',","'2'","'255.255.0.0',","'255.255.255.0',","'2604","'8.8.8.8'))","'\\n')","'abc'","'abc')","'aws_host_url'","'bluetooth',","'de","'devic","'failure'","'fffe'","'fipy')","'gpy',","'handshake'","'heart","'hello'","'hello')","'lopy',","'lte","'my_network_key'))","'my_wifi_password'","'my_wifi_ssid'","'mywifi':","'mywifikey'),","'networkid':","'p11'))","'p18'])","'p18'].","'p21')","'p21',","'p22',","'p23'))","'password'),","'publishtopic'","'py'","'pycompublishclient'","'pypypypypypypypypypypypypypypypypypypypy'","'python'),","'r')","'sigfox',","'sipy',","'success'","'to","'true'","'usb","'username',","'utf8')","'w')","'wifi'","'wifi',","'wipy'","'wlan_config'","'wlan_config':","'xy')","'your","'{\"state\":{\"desired\":{\"property\":'","'}}}'","(","(\"little\"","(%)","('10.0.0.114',","('10.0.0.8',","('c).","('wipy',","(((data[0]","((l_rom[byte]","((~temp_read","(*.pem.crt)","(*.private.pem.key)","(0","(0)","(0),","(0).","(0.0,","(0x020,","(0x040,","(0x1a0000)","(0x200,","(0xf013","(0xf014for","(1","(1)","(1),","(1,","(1,0,1)","(1,0,1,0,1,0,1,0,1)","(1,0,1,1,0,1)","(1,0,1,1,1,0,1,0,1)","(1.19.0","(10.11","(100,","(16","(2),","(2):","(2**exp).","(2,","(200)","(23)","(2g)","(3","(3)","(30000","(32","(4).","(4,","(400,200,100,300,200,400)","(4kib).","(8","(8000,11000,8000,11000,6000,13000,6000,3000,8000)","(868","(>=","(``p10``,","(``p19``,","(``p20``","(``p20``,","(``p3``","(a","(abp)","(abp).","(accelerometer,","(ack","(activ","(advanc","(ae","(after","(all,","(along","(also","(amazon","(and","(ap)","(apm","(apm)","(appeui)","(appkey)","(apple'","(arg.id()))","(at","(atqa),","(att),","(base64)","(becaus","(between","(bi","(bit","(ble)","(boot.py)","(bq24040","(bt_o):","(but","(button","(byte","(bytes,","(c)","(call","(can","(cdc)","(chain)","(char.properties()","(check_uid(list(uid),","(clang","(class","(clk,","(com","(commonli","(config.py):","(configur","(conn,","(connect","(correspond","(count_per_c","(crc","(csv)","(current","(data","(data,","(default)","(default,","(default:","(details).","(dev_addr,","(dev_eui,","(deveui)","(devic","(device_id","(device_id,","(do","(doesn't","(domoticz.py)","(e.g","(e.g.","(e.g.,","(e.g:","(eg","(either","(enabl","(encod","(europe)","(even","(except","(express","(extended).","(extern","(f013","(f014","(family,","(fast)","(filter,","(fipy,","(flash_encryption_key.bin","(float),","(for","(foreign","(function","(g).","(gap)","(high/low)","(hint:","(http://epydoc.sourceforge.net/stdlib/distutils.version.loosevers","(i","(i.e","(i.e.","(id,","(id=0x012,","(if","(ignor","(in","(inact","(includ","(input,","(insecure).","(integer)","(integer).","(ip,","(ipv4_address,","(it","(it'","(iv)","(join","(just","(l01,","(l76","(len","(len(recv_ack)","(len(recv_pkg)","(level,","(like","(lis2hh12)","(locat","(lopi","(lopy,","(lopy4,","(lora","(lora.lora).","(lora.lora):","(low","(lowercase)","(lpmac,","(ltr","(m)","(m).","(m,","(mac,","(main.py)","(major,","(make","(mani","(max","(may","(mfrc6300)","(mfrc63002hn)","(mfrc630_mf_auth_key_a","(micropython)","(mit)","(modbu","(mpl3115a2)","(must","(names)","(never","(nfc,","(no","(nodes)","(none,","(normal","(not","(note","(note:","(obj,","(often","(on","(on/off)","(onli","(optional)","(or","(ota)","(otaa)","(over","(p0)","(p1)","(p10","(p10=sda,","(p12)","(pa),","(pa).","(pack","(partit","(pic","(pin#6","(pin='p12')","(power","(putty,","(pybyt","(pycom","(pysense/pytrack),","(python","(quectel","(raw","(rb","(re)init","(read","(recommended)","(recv_data)","(regard","(remot","(repl)","(requir","(resolution)","(rgb","(rgb_bright","(rtc).","(rtr=true).","(rx_timestamp,","(same","(save","(scl)","(scl).","(sda)","(sda,","(sec,","(sec,).","(see","(select","(sequence)","(server)","(si7006","(si7006a20)","(silver","(sipy)","(sntp).","(so","(so_*","(ssid","(ssid,","(standard)","(such","(sysname='gpy',","(telnet)","(temp_msb","(that","(the","(thi","(though","(total","(true","(true):","(ttn)","(tuple)","(tx1/rx1),","(txd/rxd","(typenam","(typic","(tz","(uart)","(ubinascii.hexlify(lora.mac()).decode('ascii')))","(uctypes.array","(uctypes.ptr","(universal)","(unlik","(updat","(uplink_frequency_hz,","(upon","(use","(user","(v","(via","(wait","(wake_reason,","(wakeup)","(we","(which","(with","(wlan.ap","(write","(x86)\\pycom\\pycom","(year,","(you","({m,n}),","(~","(~0.4","(~0.8","(~1.5","(~1ua",").","*","**","****","**environ","*,","*.","*?","+","+14dbm","+22dbm","+=","+?","+pi).",",",",\"\")",",region=lora.eu868,",",timeout=none,",".","...","...)","./pyupgrad",".atom\\packages\\pymakr\\",".bin)",".callback()",".cb",".nv",".ota",".pi",".read()",".tar",".tar(.gz)",".tar.gz",".zip","/","//","/dev/cu.bluetooth","/dev/cu.usbmodempy343431","/dev/cu.usbseri","/dev/tty.usbmodem*","/dev/ttyusb0","/dev/ttyusb01","/flash","/flash.","/flash/boot.py:","/flash/cert","/flash/cert.","/flash/cert/","/flash/cert/.","/frozen","/json.htm?\"+path+\"","/lib","/manifest.json?current_ver=1.0.0","/path/to/firmware/archive.tar.gz","/sd","/sd.","/usr/local/bin.","0","0%","0)","0))","0),","0):","0);","0,","0.","0.1","0.2).","0.5","0.9","004:","005:","00:00:00","01","01)","0100","02","020","04d8","04d8:f013","04d8:f014","08","09:51:46","0:","0dbv","0x0","0x0,","0x00,","0x0000","0x001","0x00ff00","0x01","0x010),","0x010,","0x01:","0x02","0x02,","0x020","0x03","0x03,","0x030","0x030),","0x03]))","0x03]):","0x04","0x04,","0x040","0x04d8.","0x05","0x05,","0x050)])","0x050.","0x05]))","0x05]),","0x06","0x06,","0x06]))","0x07,","0x08","0x08]))","0x0f","0x0f)","0x10","0x10,","0x100,","0x1000).","0x10000","0x18","0x1a0000).","0x200,","0x28:","0x300","0x300,","0x400","0x400])","0x42","0x42,","0x77","0x7f","0x7fc)])","0x7ff),","0x8","0x80","0x8000","0x95,","0xdd,","0xef37","0xef38","0xef98","0xef99","0xf011","0xf012","0xf013","0xf014","0xf1:","0xf8],","0xf9]]","0xff)","0xff00","0}),","1","1\"')","1')","1)","1).","1);","1,","1.","1..254","1.0","1.0)","1.0.0","1.0.1","1.0.2","1.0.99","1.0.x","1.1,0,0","1.12.0.b0","1.14.3).","1.16.0.b1","1.16.x","1.17.0.b1","1.17.5.b6","1.1v","1.1v.","1.2.5,","1.25","1.4","1.5","10","10%","10)","10),","10,","10,000u","100","100%","100%.","100)","100):","1000","1000*100n","1000*channel","10000","100000.","1000000.","1000n","1000u","100hz,","100ma.","100n","100u","100us.","102.4","1024]","10:","10:30am","10h","10k","10m","10ma.","10ua","10ua.","11,","11.","1120.","115200","115200)","11bit","11db.","12","12,","12.","120m","122hz.","123","12341","125","125hz","128","128),","128,","12:","12]))","12dbv","13","13,","13604","14","14.04","146","14:23:58)","15","151","16","16\",","16.","16384","180","180.","18dbv","19.7µa","192),","192,","192.168.1.144:8000\\r\\n\\r\\n","192.168.4.1","192.168.4.1)","192.168.4.1,","1970","1:","1])","1khz","1st","2","2')","2)","2),","2):","2**e","2,","2.","2.0","2.0,","2.0exp","2.4ghz","2.5","2.7:","2.x.","20","20*100n","200","200)","200):","2000","2000.","20000.","2000mg","2005","2009","200m","2010","2013","2014).","2015","2016","2017","2017,","2018","2018,","2048","20khz","21;","224","23","230400.","24","25","25)","250","254","255","256","256)","256,","27',","28,","28.","29bit","2:","2]","2g/3g/lte","2g/gprs,","2ma","2mhz","2nd","2u","3","3)","3,","3.","3.0","3.0,","3.0.","3.0disconnect","3.0pytrack/pysense/pyscanusb","3.2768","3.3v","3.3v,","3.3v.","3.4v","3.5","3.5,","3.5.","3.5v","3.6.5","3.x,","30","30%","30,","300k","306076","31","31)","31.","3125n","32","32\",","32.","32.768","32768","329al","32:","366","375","37781.dup","37781.dup',","37781.dup)","37781.zip","384","38638.dup","38638.dup')","38638.dup',","38638.zip","3:","3]))","3d.","3gpp","3rd","3v3","3v3).","3vpp","4","4,","4.2.1","4/5","4096","433mhz","433mhz.","443)[0][","450ma.","48","48).","48656c6c6f","4:","4kib","4mb","4mb.","4s","5","5)","5,","5.0.0.0d","5.1.1.0","5.5","5.5v","5.5v.","50%","5000","5000m","500:","500u","512","512kb","54854","59","5996938","5khz","5th","5v","6","6,","60","600","64","64\"","64).","64.","65","65535.","6dbv","7","7).","7,","7.","7.8.0","70,","70b3d5499585fca1.","71","78","7ua","8","8'))","8,","8.","8.8.8.8,","8/10/+,","8/10/+.","80","80%","80)[0][","8000","8000)","8080","80m","8192","8441)[0][","849","863","863000000","868","868000000","868000000,","868mhz","868mhz/915mhz","870000000","8883","8]))","8mb","8mb.","9","9):","9,","9.1.0","90","90.","902.0.39.1)]","902000000","912","915","915mhz","921600","921600.","928","928000000","9600)","99%.",":","=","==","==============",">",">=",">>",">>=",">>>",">>>,",">>>.","?","?!?","??","@","@,","[","[########################################]","['lora',","['p17',","[(0x001,","[(0x100,","[0]","[0x100,","[0x43,","[33080]","[38638]","[=========================]","[[0x43,","[]","[command","[command]","[e.sec","[gcc","[global","[n/a]","[pytrack]","[r]","[rom]","[usb","[w].","[wob]","[wob]]","\\","\\.","\\n\\n\")","\\r\\n+cgsn:","],","^","__init__(self):","__init__(self,","_lib/pycoproc_","_lora_pkg_ack_format","_lora_pkg_format","_search_rom(self,","_seconds_handler(self,","_stub_","_thread","_thread.allocate_lock()","_thread.exit()","_thread.get_ident()","_thread.locktyp","_thread.stack_size([size])","_thread.start_new_thread(discovery_loop,","_thread.start_new_thread(function,","_thread.start_new_thread(th_func,","`","``p11``","``p14``)","``p20``","``p21``)","``p21``,","``p22``and","``p23``)","``p4``)","`devic","`p10`","`p9`","`start_level`","a20)","a_lock","a_lock:","ab001234\",","abc1de45bf).","abi","abi,","abil","abov","above)","above,","above.","abp","abs()","abs_done_0","absolut","abstract","acc","acc.enable_activity_interrupt(2000,","acc.pitch()","acc.roll()","acceler","acceleration,","acceleromet","accelerometer,","accelerometer.","accelerometer:","accept","accepted!\")","accepted.","access","access.","accessori","accommod","accord","accordingly.","account","account.","account:","accur","achiev","ack","ack_pkg","acquir","act","action","action.","activ","activated,","activated.","activation)","activation:","activation;","active.","activities.","activity/inact","actual","ad","adafruit","adafruit'","adapt","adapterwifilook","adapterwifiwhen","adc","adc()","adc(0)","adc.","adc.attn_0db,","adc.attn_11db","adc.attn_2_5db,","adc.attn_6db,","adc.channel","adc.channel(*","adc.channel(pin='p13')","adc.channel(pin='p16')","adc.channel(pin='p16',","adc.deinit()","adc.init(","adc.vref(1100)","adc.vref(vref)","adc.vref_to_pin('p22')","adc.vref_to_pin(pin)","adc_c","adc_c()","adc_c.value()","adcchannel","adcchannel()","adcchannel.","adcchannel.deinit()","adcchannel.init()","adcchannel.value()","adcchannel.value_to_voltage(value)","adcchannel.voltage()","add","add(1,","add(number1,","add.","added!","added,","addit","additional,","additionally,","addr","addr.","addr=0x23,","addr=i2c.scan()[0])","addr_typ","addr_type,","address","address)","address,","address.","address/credentials,","address:","address:\"","address]","address_book","addrsiz","addrsize=8)","adher","adjust","adr","adr,","adr=false,","adr=true,","adv","adv:","adv_typ","adv_type,","advanc","advertis","advertised.","advertisement.","advertisements,","advertisements.","advertiser.","advertiser:","advertising.","ae","aes(key,","aes.mode_cbc:","aes.mode_cfb","aes.mode_cfb,","aes.mode_cfb.","aes.mode_cfb:","aes.mode_crt.","aes.mode_ctr.","aes.mode_ctr:","aes.mode_ecb","aes.mode_ecb.","aes.mode_ecb:","aes.segment_128","aes.segment_128:","aes.segment_8","aes.segment_8,","affect","africa.","after,","after.","again","again.","against","aggreg","agnost","aim","air","air\"","air:","alarm","alarm):","alarm.","alarm.callback(handler,","alarm.callback(none)","alarm.cancel()","alarm:","alarms.","alex!\"","algorithms.","alia","align","alive.","all()","all:","alloc","allocated,","allocated.","allow","allowed),","allows,","allows.","along","alongsid","alphanumer","alreadi","als_gain_1x,","als_gain_1x,als_gain_2x,","als_gain_48x,","als_gain_4x,","als_gain_8x,","als_gain_96x","als_int_100,","als_int_150,","als_int_200,","als_int_250,","als_int_300,","als_int_350,","als_int_400","als_int_50,","als_rate_100,","als_rate_1000,","als_rate_200,","als_rate_2000","als_rate_50,","als_rate_500)","als_rate_500,","also,","alt","alt)","alt=","alter","altern","alternatively,","although","altimet","altitud","altium","alway","always_on","amazon","ambient","ambiguity.","ambl","amount","amount.","amplitud","amplitude)","analog","analogu","anchored).","and/or","anoth","another,","another.","answer","answer.","antenna","antenna),","antenna,","antenna.","antenna=none)","antenna=none,","antenna=wlan.int_ant)","anticip","any()","any)","any).","any...)","anymore.","anyth","anyway","ap","ap)","ap.","api","api).","api.","apin","apin()","apm","app_eui","app_eui,","app_key","app_key)","app_key),","app_swkey","app_swkey))","app_swkey).","appar","appear","appear,","appear.","appear:","appears,","appears.","append","appeui","appimg","appimg.bin","appkey","appkey)","appkey.","appl","appli","applic","application)","application,","application.","applications,","applications.","applied,","applied.","approach.","appropri","approxim","apr","apt","arbitrari","arbitrarili","arch:","architecture.","archiv","archive,","archive.","arduino,","are.","are:","area","area.","arg","arg:","arg=none)","arg=none,","argentina.","args[,","argument","argument,","argument.","arguments,","arguments.","arguments:","aris","arithmet","around","array","array,","array.","array.append(val)","array.array(typecode[,","array.extend(iterable)","arriv","arrive.","arrow","articl","artifact","as923","ascii","asia","ask","aspir","assert","asserted,","assertions,","asset","asset_that_will_be_removed.wav","assign","assist","associ","assum","astrik","asynchron","at&t,","at.","at:","atmospher","atom","atom,","atom.","atom/vscod","att","attach","attempt","attempted.","attend","attenu","attn","attn=adc.attn_0db)","attn=adc.attn_11db)","attribut","attributes:","au915]","australia","australia,","auth","auth,","auth:","auth=(app_eui,","auth=(dev_addr,","auth=(dev_eui,","auth=(net.sec,","auth=(network.wlan.wpa2,","auth=(wlan.wpa2,","auth=(wlan.wpa2,'www.wipy.io'),","auth=(wlan.wpa2_ent,","auth=(wlan.wpa2_ent,),","auth=none,","auth=original_auth,","authent","authenticated,","authentication.","author","authoris","authorise.","auto","autom","automat","automatically).","automatically,","automatically:","avail","availability/non","available,","available.","available_net","available_nets])","avoid","aw","await","awar","aware,","away","awoken","aws,","aws.","aws_client_cert","aws_host","aws_port","aws_private_key","aws_root_ca","awsiotmqttclient(config.client_id)","awsiotmqttshadowclient(config.client_id)","axi","axis.","b","b'456')","b'notsuchsecretkey'","b'ping':","b,","b:","b]","back","back,","back.","backend","backend).","backend,","backend.","background.","backlog","backup","backup.","backup.cb","backup.nv","backup.ota","bag","band","band,","band.","band=20\"')","band=none)","bands.","bandwidth","bandwidth:","bandwidth=lora.bw_125khz,","bang","bar","bare","baremet","barometr","base","base64","baseboard","basi","basic","basic):","basis.","batteri","battery,","baud","baudrat","baudrate.","baudrate=100000)","baudrate=100000,","baudrate=1000000,","baudrate=20000)","baudrate=2000000,","baudrate=500000,","baudrate=9600)","baudrate=9600,","be","be,","be.","be:","bear","beat.","becom","befor","before.","begin","beginn","beginners,","beginning.","behav","behaviour","behaviour).","behaviour.","behind","being,","belong","below","below).","below,","below.","below:","benefit","besid","best","better","between","beyond","bf_len","bf_po","bh%ds.","bh1750fvi","bh1750fvi.bh1750fvi(i2c,","bh1750fvi.py.","bh1750fvi:","bi","big","bigger","bin()","binari","binaries:","binascii","binascii.hexlify(machine.unique_id())","binascii.hexlify(wl.mac())[6:]","binascii.hexlify(wl.mac())[:6]","binascii.unhexlify('00000005'))[0]","bind","bind()","bit","bit)","bit,","bit.","bit/pulse,","bit:","bitfield","bitfield).","bitfield,","bitfields:","bits,","bits.","bits=12)","bits=8,","bitwis","black","blank","blank,","ble","blink","blink.","block","block)","block,","block.","block:","block_address","blocked.","blocking,","blocksiz","blue","blue,","blue.","bluetooth","bluetooth()","bluetooth,","bluetooth.adv_128service_data,","bluetooth.adv_128srv_cmpl,","bluetooth.adv_128srv_part,","bluetooth.adv_16srv_part,","bluetooth.adv_32service_data,","bluetooth.adv_32srv_cmpl,","bluetooth.adv_32srv_part,","bluetooth.adv_adv_int,","bluetooth.adv_appearance,","bluetooth.adv_dev_class,","bluetooth.adv_flag,","bluetooth.adv_manufacturer_data","bluetooth.adv_manufacturer_data)","bluetooth.adv_name_cmpl)","bluetooth.adv_name_cmpl))","bluetooth.adv_name_cmpl,","bluetooth.adv_name_short,","bluetooth.adv_service_data,","bluetooth.adv_t16srv_cmpl,","bluetooth.adv_tx_pwr,","bluetooth.advertise([enable])","bluetooth.advertise(true)","bluetooth.bl","bluetooth.callback(trigger=bluetooth.client_connect","bluetooth.callback(trigger=none,","bluetooth.char_notify_ev","bluetooth.char_notify_event.","bluetooth.char_read_ev","bluetooth.char_read_event,","bluetooth.char_write_event,","bluetooth.char_write_event.","bluetooth.char_write_event:","bluetooth.client_connected,","bluetooth.client_connected:","bluetooth.client_disconnect","bluetooth.client_disconnected,","bluetooth.client_disconnected:","bluetooth.conn_adv,","bluetooth.conn_dir_adv,","bluetooth.connect('112233eeddff')","bluetooth.connect(adv.mac)","bluetooth.connect(mac_addr)","bluetooth.deinit()","bluetooth.disc_adv,","bluetooth.disconnect_client()","bluetooth.events()","bluetooth.ext_","bluetooth.ext_ant.","bluetooth.get_adv()","bluetooth.get_advertisements()","bluetooth.init(id=0,","bluetooth.int_ant,","bluetooth.isscanning()","bluetooth.isscanning():","bluetooth.new_adv_event,","bluetooth.non_conn_adv,","bluetooth.prop_auth,","bluetooth.prop_broadcast,","bluetooth.prop_ext_prop","bluetooth.prop_indicate,","bluetooth.prop_notify,","bluetooth.prop_read):","bluetooth.prop_read,","bluetooth.prop_write,","bluetooth.prop_write_nr,","bluetooth.public_addr,","bluetooth.public_rpa_addr,","bluetooth.random_addr,","bluetooth.random_rpa_addr","bluetooth.resolve_adv_data(adv.data,","bluetooth.resolve_adv_data(data,","bluetooth.scan_rsp","bluetooth.service('abc123')","bluetooth.service(uuid,","bluetooth.service(uuid=b'1234567890123456',","bluetooth.set_advertisement(*","bluetooth.set_advertisement(name=\"advert\",","bluetooth.set_advertisement(name='lopy',","bluetooth.start_scan(","bluetooth.start_scan(10)","bluetooth.start_scan(20)","bluetooth.start_scan(timeout)","bluetooth.stop_scan()","bluetoothserverservice.","blynk","board","board'","board).","board,","board.","board/embed","board/soc","board/soc.","board=gpi","boards,","boards.","book","book.","bool","boolean","boolean.","boot","boot\"","boot,","boot.","boot.pi","boot.py.","boot:","boot;","booting,","bootload","bootloader,","bootloader.bin","bootloader0","bootloader1","bootloader1*","bootloader2","bootloader2*","bootrom","boots,","boots.","both","both.","bottom","bound","bound.","box","box!","brace","branch","brazil.","break","brew","bright","bring","broadcast","broken","broken.","broker","broker,","broker.","brows","browser","bsd","bssid","bssid,","bssid=none,","bt","bt.connect(adv.mac)","bt.get_adv()","bt.resolve_adv_data(adv.data,","bt.start_scan(","bt_o.events()","bu","buf","buf)","buf):","buf,","buf.","buf:","buffer","buffer,","buffer.","bufsize.","bug","build","build/gpy/release/bootloader/bootload","build/gpy/release/gpy.bin_enc_0x10000","build/gpy/release/lib/partitions.bin_enc","built","builtin","burn","burn_efus","burn_key","burnt","bus,","bus.","bus:","buse","business.","but,","buttom","button","button)","button).","button,","button.","buttons.","buy","bw","bypass","byte","byte)","byte,","byte.","bytearray","bytearray(5)","bytearray(8)","bytearray(blocksize)","bytes([0x01,","bytes([0x10]))","bytes)","bytes).","bytes,","bytes.","bytes:","bytes_at()","c","c,","c.","c/c++","c:\\program","c]","ca","ca.pem","ca_cert","ca_certs='/flash/cert/ca.pem')","ca_certs='/flash/cert/ca.pem',","ca_certs=none)","ca_certs=none,","cabl","cable.","cable/wir","cables,","cach","calendar","calibr","call","call,","call.","callable()","callable.","callback","callback,","callback.","called,","called.","called:","calls:","came","can't","can(0,","can(mode=can.normal,","can.callback(handler=can_cb,","can.callback(trigger,","can.deinit()","can.events()","can.filter_list","can.filter_list,","can.filter_mask","can.filter_rang","can.filter_range,","can.format_both,","can.format_both.","can.format_ext,","can.format_std","can.format_std,","can.init(mode=can.normal,","can.norm","can.normal,","can.recv()","can.recv(timeout=0)","can.rx_fifo_not_empti","can.rx_fifo_not_empty,","can.rx_fifo_overrun","can.rx_fifo_overrun,","can.rx_fram","can.rx_frame,","can.send(id,","can.send(id=0x0020,","can.send(id=0x010,","can.send(id=0x012,","can.send(id=12,","can.silent,","can.silent.","can.soft_filter(can.filter_list,","can.soft_filter(can.filter_mask,","can.soft_filter(can.filter_range,","can.soft_filter(mode,","can.soft_filter(none)","can_cb(can_o):","can_o.recv())","cancel","canonname,","can't","capabilities.","capabl","capacit","capit","captur","card","card'","card)","card,","card.","care","carefulli","carefully:","carri","carrier","carrier'","carrier,","carrier=none)","carrier_duty_perc","carrier_freq_hz","carrier_level","case","case)","case).","case,","case.","cases,","cases.","cat","categori","categoris","catm1","caught","caught,","caus","cause.","cb","cdc","ce","cell","cell)","cells,","cellular","centr","central","centuri","cert","cert_req","cert_reqs=cert_none,","cert_reqs=ssl.cert_required,","certain","certfil","certfile='/flash/cert/client.crt')","certfile=none,","certif","certificate\"","certificate,","certificate.","certificate.pdf)","certificates,","certifl","chain","chaining.","chanc","chang","change.","changed.","changes.","changes:","channel","channel,","channel.","channel:","channel=1,","channel=6,","channel=7,","channels,","chapter","char","char.read()))","char1_cb_handler(chr):","char1_read_count","char2_cb","char2_read_count","charact","character)","character.","characterist","characteristic,","characteristic.","characteristic.callback(trigger=none,","characteristic.events()","characteristic.instance()","characteristic.properties()","characteristic.read()","characteristic.uuid()","characteristic.value()","characteristic.value(123)","characteristic.value([value])","characteristic.write(b'x0f')","characteristic.write(value)","characteristics,","characteristics.","characters,","characters.","charg","charge,","charger","charger.","chars:","chart","chart).","check","checkbox","checking.","checkout","checksum.","chg","chip","chip_id","choic","choice.","choos","chose","chosen","chosen.","chr()","chr.events()","chr1","chr2.callback(trigger=bluetooth.char_read_event,","chrono","chrono.read()","chrono.read_ms()","chrono.read_us()","chrono.reset()","chrono.start()","chrono.stop()","chrono:","chronomet","chronometer.","chunk","cid","cid=1)","cid=1.","cid=3.","cipher","cipher.","cipher.decrypt(msg[16:])","cipher.encrypt(b'attack","ciphertext","circle'","circumfer","circumstances.","claim","claim,","clariti","class","class,","class.","class.html).","class:","classes,","classes.","classes/funct","classic","class'","claus","clean","clear","cli","cli.","cli.ex","click","click,","client","client,","client.","client.check_msg()","client.connect()","client.publish(topic=\"youraccount/feeds/lights\",","client.set_callback(sub_cb)","client.subscribe(topic=\"youraccount/feeds/lights\")","client_id","clients,","climates),","clipboard.","clk,","clk,p11","clock","clock()","clock:","close","close()","closed.","cloud","cloud.","clutter","cmath","cmath.cos(z)","cmath.e:","cmath.exp(z)","cmath.log(z)","cmath.log10(z)","cmath.phase(z)","cmath.pi:","cmath.polar(z)","cmath.rect(r,","cmath.sin(z)","cmath.sqrt(z)","cmd","cmd_matchrom","cmd_readrom","cmd_searchrom","cmd_skiprom","code","code).","code,","code.","code:","codes.","codes:","coding,","coding_r","coding_rate=lora.coding_4_5,","coil","coil_quantity)","coil_quantity=100","coil_statu","coil_status))","coils,","cold","collect","collected,","collection.","collis","collision,","colombia","color","color,","colour","colour.","colours.","com","com1","com4)","com6","combin","combinations;","combined):","come","comma","command","command):","command,","command.","command:","commands,","commands.","commands:","comment","common","commonli","commun","communication.","compani","compar","comparison.","comparisons.","compat","compatibility.","compens","compil","compile()","complement","complementari","complet","complete,","complete.","completed!","completed,","completed.","completely.","completes.","completion:","complex","compliant","compon","component.","components:","compos","comprehens","comput","computer)","computer);","computer,","computer.","computer:","concept","concis","condit","conditions:","config","config)","config.aws_client_cert)","config.aws_port)","config.aws_private_key,","config.last_will_msg,","config.pi","config.py)","config=['dhcp'","configtuple])","configur","configurable,","configuration.","configuration:","configured.","confirm","conform","confus","congratul","conn","conn.disconnect()","conn.services()","conn_cb","conn_disconn_timeout","connecor.","connect","connect,","connect.","connected\")","connected),","connected).","connected,","connected.","connecting,","connection,","connection.","connection.disconnect()","connection.in","connection.isconnected()","connection.services()","connections),","connections.","connectivity,","connectivity.","connector","connector)","connector,","connector.","consecut","consid","consider","consist","consol","console,","console.","const","const(0x33)","const(0x55)","const(0xcc)","const(0xf0)","const(120)","const(123)","const(2","const(4096)","const_i","const_x","constant","constantli","constants.","constrained,","construct","construct.","constructor","constructor.","consum","consumpt","consumption.","contact","contain","contain.","contained.","contains:","content","content.","contents,","contents/resources,","contents]","context.","contigu","continu","continuation`","continuo","contract","contract,","contract.","contribut","control","control)","control.","controller,","controller.","controllers.","conveni","convers","convert","cooki","coord","coordin","copi","copied/upload","copy,","copy/past","copy/writ","copyright","core","corner","corner.","correct","correct,","correctli","correctly,","correctly.","correspond","cosin","count","count).","count_per_c","count_remain","count_remain)","counter","counter,","counters,","countri","coupl","courtesi","cover","coverag","cpu","cpu,","cpython","cpython.","cpython'","cr","crash","crc","crc8(self,","creat","create.","create/regist","created,","created.","creation.","credenti","credentials.","credentials:","critic","crosswind","crucial","crypto","crypto.getrandbits()","crypto.getrandbits(128)","crypto.getrandbits(bits)","crypto1","cryptograph","cryptographi","cs","ct","ctr","ctrl","ctrl+d","ctrl_c_on_connect","cts))","cts.","ctype","current","current.","current_v","currently,","currently:","cursor","cursor.","custom","customcallback(client,","customcallback)","customis","customisable,","customshadowcallback_delete(payload,","customshadowcallback_delta(payload,","customshadowcallback_update(payload,","customshadowcallback_update,","cut","cycl","cycle.","cycles.","d","d,","d.","d.setvariable('presence:livingroom','1')","d0dc708","d]","dac","dac.deinit()","dac.init()","dac.tone(frequency,","dac.write(0.5)","dac.write(value)","dac_ton","dac_tone.tone(1000,","damag","damaged.","damien","darwin","dash","dashboard","dashboard!","dashboard'","dashboard.","dashboard;","dat0,","data","data)","data):","data,","data.","data;","data=b'123',","data=bytes([0x01,","data=bytes([1,","data=none,","data[6]","data[7]","data[i]","data_typ","data_type)","database.","datagram","datasheet","datasheets.","datatyp","date","date,","date/tim","date/time.","datetim","datetime.","dawn')","day[,","days),","db","dbm).","dbm.","dc","de","deal","debian:","debug","debug=false)","debug`","debuggin","decid","decision.","declar","decompos","decreas","decrypt","decryption.","deep","deepsleep","deepsleep()","deepsleep.","deepsleep.disable_pullups(pins)","deepsleep.disable_wake_on_fall(pins)","deepsleep.disable_wake_on_raise(pins)","deepsleep.enable_auto_poweroff()","deepsleep.enable_pullups(pins)","deepsleep.enable_wake_on_fall(pins)","deepsleep.enable_wake_on_raise(pins)","deepsleep.get_wake_status()","deepsleep.go_to_sleep(seconds)","deepsleep.hw_reset()","deepsleep.pin_wake:","deepsleep.power_on_wake:","deepsleep.set_min_voltage_limit(value)","deepsleep.timer_wake:","def","default","default)","default).","default,","default.","defaults.","defin","define.","defined,","defines).","definit","definitions,","definitions.","degre","degrees.","deinit()","deinitialis","delay","delays.","delet","delete:","deliv","delta","demo","demo,","demonstr","denot","depend","dependent,","depict","deploy","depth","dereferenc","dereference,","describ","descript","descriptor","descriptor,","design","desir","dest","dest)","destin","destroy","detach","detail","details.","detect","detected,","detected.","detection)","determin","dev","dev_addr","dev_eui","develop","development.","deveui)","devic","device!","device\"","device\")","device'","device)","device),","device).","device):","device,","device.","device...","device:","device;","device_class","device_class=lora.class_a)","device_id","device_id):","device_id,","deviceid,","devices).","devices,","devices.","devices:","deviceshadowhandl","deviceshadowhandler.shadowdelete(customshadowcallback_delete,","deviceshadowhandler.shadowregisterdeltacallback(customshadowcallback_delta)","deviceshadowhandler.shadowupdate(jsonpayload,","devicetoken","devkit","dfu","dfu,","dfuidle,","dhcp","dht11/dht22/am2302","diagram","dialog","dialout","diamet","dict","dictat","dictionari","dictionaries,","dictionary),","diff","diff)","diff):","differ","differences.","different,","differently.","difficult","digest","digest.bin","digest.bin_enc","digit","dio","dir()","direct","directional,","directions).","directli","directly,","directly.","directori","directories.","directory).","directory.","directory:","disabl","disable_irq","disable_irq()","disabled)","disabled,","disabled.","discharges.","disconnect","disconnected\")","disconnected.","discontinued,","discov","discret","discuss","disengag","display","display.","distinguish","distribut","distribute,","distributor","divmod()","dns)","dns_server)","dns_server).","do","do.","do:","doc","docs),","docs.","document","document).","documentation,","documentation.","does.","doesn't","doesn't","doing.","domain","domain,","domoticz","domoticz(\"\",","domoticz:","don't","done","done!","done,","done.","don't","dot","doubl","doubt","down","down.","downgrad","downlink","downlink_frequency_hz)","download","dq0054e","dr:","dr=0,","dr=none)","dr_max)","dr_max:","dr_max=6)","dr_min,","dr_min:","dr_min=5,","drag","drain","draining_freq","draw","drawbacks.","dri","drive","drive'","drive','chris':'3236","drive','joe':'1301","driven","driver","driver,","driver.","drivers,","drivers.","drivers:","drivers;","drop","dropdown","ds","ds.enable_pullups('p17')","ds.enable_pullups(['p17',","ds.enable_wake_on_fall('p17')","ds.enable_wake_on_fall(['p17',","ds.get_wake_status()","ds.go_to_sleep(60)","ds18b20","ds18x20","ds18x20(ow)","dual","due","dup","duplex","duplic","durat","duration):","duration,","duration.","duration[i]","dure","during:","duti","duty,","duty_cycl","duty_cycle=0.5)","e","e)","e.g.","e.g.:","e.g:","e.ssid","e:","each","eap","earlier","earlier,","eas","easi","easier.","easiest","easili","easy.","echo","eco","ecosystem","ed","edg","edge.","edit","editor","editor'","editors,","effect","effect.","effectively,","effici","efficient.","effort","efus","efuse,","efuses.","either:","eitherbluetooth.int_ant,","elaps","elapsed.","elapses,","elapses.","electr","electron","element","elements,","elements.","elements:","elev","elif","else:","elsewhere.","email","embed","emerg","empow","empti","empty,","emul","enabl","enable.","enable_auto_poweroff","enable_irq","enable_irq(i)","enable_pul","enable_pull)","enabled,","enabled.","enabling,","encapsul","encod","encoding,","encrypt","encrypt_key=flash_encryption_key.bin","encrypted,","encrypted.","encrypted;","encryption)","encryption.","end","end.","end=\"\")","endian","endianness,","endpoint","ends,","energi","enforced).","enforced.","enough.","ensur","enter","enter,","enterpris","entir","entri","enumerate()","environ","environment:","environments,","eof.","epoch","epoch,","epoch:","equal","equival","eras","erase_al","erase_f","erase_region","errat","error","error,","errors,","esd","esp32","esp32'","esp32')","esp32).","esp32,","espbaud**","espbaud.","espport","espport**","espressif","espressif'","esptool","esptool.","essenti","est","establish","etc)","etc).","etc.","etc.)","etc.).","etc.);","eu","eu868","eu868,","eui","eui,","eui.","europ","europe,","eval()","evalu","even","event","event,","event.","eventmask","eventmask)","eventmask])","events.","events:","everyth","everything'","exact","exactitud","exactli","exactly.","exampl","example)","example,","example.","example:","example;","examples,","examples.","examples/docs)","examples:","exce","exceeded.","excel","except","except:","exception,","exception.","exception:","exchang","exclus","exclusive;","exec()","execut","executed,","executed.","executes\")","execution,","execution.","execution...","exemple,","exist","existence).","exists)","exists,","exists.","exit","exits.","exp","exp(x)","exp)","expand","expans","expect","expected,","expected.","experi","experienc","expir","expire)","expired,","explain","explan","explicit","explicitli","explicitly,","explor","exponent.","exponenti","expos","express","expression,","expression.","expressions).","extend","extended)","extended=false)","extended=true)","extens","extension:","extern","externally.","extnt","extra","extract","extract_public_key","extrapref","extraprefs]","f","f,","f.close()","f.readall()","f.readinto(buffer)","f.write('test","f014","f:","facil","fact","facto'","factor","factor,","factor.","factori","factory,","factory.","fail","fail,","fail.","failed\")","failed,","fails,","fails.","failur","failure,","failure.","fall","fallback","falling])","fals","false)","false).","false,","false.","famili","familiar","familiaris","family,","far","fashion.","fast","faster","faster.","fat","fat16","fat16/32","fat32.","favourit","fb_bit","fcc","featur","feature,","feature.","feature;","features,","features.","features/functionality.","features:","februari","fed","fedora:","feed","feedback.","feel","femal","fetch","few","ffi","fi","fi/bt","field","field).","field.","fields.","fields:","fifo","fifo.","file","file,","file.","file:","file=sys.stdout)","file]","filenam","files,","files.","files\\pycom\\pycom","filesystem","filesystems.","filezilla","filezilla,","fill","filter","filter()","filter_list","filter_list)","filtering.","filters,","final","finally,","find","finish","finished,","finished.","finite.","fipi","fipy)","fipy,","fipy.","fipy:","fireftp","firmare_version.bin,","firmli","firmwar","firmware,","firmware.","firmware:","firmware;","firmware_1.0.0.bin","firmware_1.0.1.bin","first","first).","first,","first.","firstbit","firstbit=spi.msb)","firstbit=spi.msb,","firstli","fit","fix","fix.","fixed,","flag","flag.","flag;","flags.","flash","flash!","flash,","flash.","flash/pybytes_config.json","flash:","flash_crypt_cnt","flash_crypt_config","flash_encrypt","flash_encryption_key.bin","flash_freq","flash_mod","flash_siz","flat","flavours:","fleet;","float","float)","float).","float32).","floats,","flow","flushed).","fmt","fmt.","folder","folder).","folder,","folder.","folder:","follow","following,","following:","follows:","forc","forev","forever.","forever...)","form","form.","form:","format","format(s)","format)","format).","format,","format.","formats.","formed.","former","forms.","forum","forum?","forward","forwarder\"","forwarder.","found","found!')","found,","found.","four","fp","fraction","frame","frame.","frame_format","frame_format=can.format_std,","frames,","free","free.","freeli","freq","frequenc","frequency)","frequency,","frequency.","frequency:","frequency=","frequency=5000)","frequency=868000000)","frequency=868000000,","frequency=912000000)","frequency=none)","frequent","fro","from,","from.","from/to","frozenset","frozenset([e.ssid","frozenset([key","fs,","fs1,","fsk","fsk,","fsk.","fsm","ftdi","ftdi]","ftdi`","ftp","ftp.","ftp:","ftp://192.168.4.1","ftp>","fulfilled.","full","full.","fulli","function","function,","function.","functional,","functionality,","functionality.","functions,","functions.","functions/assignments/etc.","functions/class","furnish","further","futur","future,","fwtool","fwtool.","g","g01","g01)","g01),","g01,","g01.","g01:","g1d8b5e5","g23","gain","gain:","gamma","gap","gap.","garbag","gate","gateway","gateway,","gateway.","gateways.","gather","gatt","gattccharacterist","gattcconnect","gattcconnection.","gattcservic","gattscharacterist","gattscharacteristic.","gattsservic","gb.","gc","gc.collect()","gc.collect().","gc.disable()","gc.enable()","gc.mem_alloc()","gc.mem_free()","gc.mem_free()))","gener","generate_flash_encryption_key","generate_signing_key","generated,","generated:","generator.","gentl","geograph","geoloc","geolocation.","george,","gerber","get","get/set","get_adv()","getattr()","gil","github","github.","give","given","given,","given.","global","globals()","glonass","glonass)","gmtime()","gnd","gnd.","gnss)","gnu","go","go_to_sleep()","goe","goldleaf","gone","good","googl","google'","gp","gpi","gpi08","gpi09","gpio","gpio.","gpio16","gpio21","gpio=\"p20\",","gpio=\"p21\",","gpio_list).","gpl","gps,","gpy,","gpy.","gpy.bin_enc_0x10000","gpy.bin_enc_0x1a0000","gpy/fipi","gpy:","grant","granted,","great","greater","green","green.","grid","grid.","ground","group","group.","groups,","groups.","grow","guarante","gui","guid","guide,","guide.","gyp","h","h,","h]","half","halt","hand","hand,","handl","handler","handler)","handler.","handler:","handler=char2_cb_handler)","handler=conn_cb)","handler=lora_cb)","handler=none,","handling.","hang","happen","happens,","happens.","harald","hard","hardwar","hardware,","has_joined()","hasattr()","hash","hash()","hash,","hash.","hash.digest()","hash.hexdigest()","hash.update(data)","hasher","hasn't","have","haven't","haven't,","header","header)","header).","header,","headers,","heap","heap.","heap_lock()","heap_unlock()","heart","heartbeat","heartbeat.","held","held,","hello","help","help(machine)","help.","help`","here","here\"","here'","here)","here).","here,","here.","here...","here:","herebi","hertz.","hex","hex()","hexadecim","hexidecim","hexlify)","hidden","hidden,","hidden=false)","hide","high","high!\")","high,","higher","higher)","higher.","highest","highli","hillview","hint:","his/her","histori","history:","hold","hold.","hold_tim","hold_time_sec","hold_time_sec:","holder","holds.","hole,","home","homebrew:","hong","host","host/port","hour","hour,","hour[,","how.","however,","http","http/1.0\\r\\n\\r\\n\")","http/1.0\\r\\nhost:","http/1.1\\r\\nhost:","http://127.0.0.1:8000/manifest.json?current_ver=1.0.0","http://sourceforge.net/p/dfu","https://backend.sigfox.com/activ","https://backend.sigfox.com/auth/login","https://docs.pycom.io/chapter/advance/cli.html","https://github.com/pycom/pycom","https://software.pycom.io/downloads/sequans2.html","https://www.pycom.io/opensource/licens","human","humid","humidity.","hundr","hyperbol","hz","hz.","i))","i,","i.e.","i.e.:","i/o","i2c","i2c(0)","i2c(0,","i2c,","i2c.","i2c.deinit()","i2c.init()","i2c.init(i2c.master)","i2c.init(i2c.master,","i2c.init(mode,","i2c.mast","i2c.master()","i2c.master)","i2c.master,","i2c.master:","i2c.readfrom(0x42,","i2c.readfrom(addr,","i2c.readfrom_into(addr,","i2c.readfrom_mem(0x42,","i2c.readfrom_mem(addr,","i2c.readfrom_mem_into(addr,","i2c.scan()","i2c.writeto(0x42,","i2c.writeto(addr,","i2c.writeto(addr=0x42,","i2c.writeto_mem(0x42,","i2c.writeto_mem(addr,","i2c;","ibeacon","ibeacons).","iccid","icon","id","id()","id)","id).","id):","id,","id.","id=0x12","idea","ideal","ident","identifi","identifier.","identity='myidentity',","identity=none)","idl","idle,","idle.","idx,","if,","ified\"","ignor","ignored.","illustr","imag","image.","images,","imagin","imei","imei.","immedi","immediate.","immediately,","immediately.","immutable,","implement","implementation),","implementation.","implemented,","implemented.","implicit.","implied,","import","important:","importantly,","importing/us","improp","improv","in,","in.","inact","inc(index,","inc.","incas","includ","include:","inclus","incom","inconsist","incorrect","increas","increase,","increment","indefinit","indefinitely.","indent","indentation,","independ","index","index.","index:","indic","individu","indoor","infinit","infinite.","infinity.","info","info)","info).","info,","inform","information.","informational.","information”","infrar","infrequ","inherit","init","init()","initalis","initi","initialis","initialisation.","initialisation.:","initialised,","initialised.","inod","inp","input","input()","input,","input.","input/output).","input_quantity)","input_quantity=100","input_statu","input_status))","inputs).","insert","insid","instal","install.","installation.","installation:","installed.","instanc","instance).","instance,","instance.","instance:","instanti","instantiated.","instantiation.","instead","instead,","instead.","instruct","instruction:","instructions,","instructions.","int","integ","integer,","integer.","integers.","integr","integration.","integration:","integrity.","intellig","intend","intent","interact","interest","interfac","interface\"","interface)","interface,","interface.","interface...","interfaces.","interfer","intermedi","intern","internal).","internal/extern","internet","interog","interpret","interpreter.","interrupt","interrupt).","interrupt.","interrupts,","interrupts.","interrupts;","interv","interval,","interval.","intervals,","introduc","introduct","ints.","invalid","invent!","invers","inversion.","io","ion/li","iot","iot,","iot.","iot:","ip","ip,","ip67","ipv4","ipv4_address","ipv4_address,","iq","irq","irrepar","irrevers","is,","is:","isinstance()","isn't","iso14443a,","isprimari","isprimary=true)","isprimary=true,","issu","issubclass()","issue.","issues,","is”,","it!","it'","it)","it,","it.","it:","item","items,","items.","iter","iter()","iterable.","iterable])","itself","itself.","it'","iv","iv)","iv,","jan","japan.","join","joined.","joined...')","json","json,","json.loads(payload)","json.pi","jsonpayload","jst","jump","jumper","jumpers,","kbp","keen","keep","kept","key","key'))","key).","key,","key.","key.bin","key.bin)","key.bin,","key_typ","key_type,","keyboard","keyboard.","keyboardinterrupt","keyfil","keyfile='/flash/cert/client.key',","keyfile=none,","keys,","keyword","keyword,","keyword.","khz","khz.","kib)","kind","kind,","kit","know","known","known_net","known_nets[net_to_use]","known_nets])","known_nets_nam","known_nets_names)","kong,","kwarg","kwargs])","l","l)","l,","l01","l01'","l01,","l01/w01","l01:","l04","l04,","l04:","l76","l76.coordinates()","l76gnss","l76gnss(py,","l76gnss(pytrack","l76gnss.","l76gnss.coordinates(debug","l_rom","l_rom,","l_rom:","lab","label","lack","lane'}","languag","language.","lap","lap\"","lap)","lap))","larg","last","last).","last_trigg","last_will_msg","last_will_top","later","later,","latest","latest.","latitud","latitude.","latter","layer","layer\")","layers.","layers:","layout","layout/gitbook/assets/l01","layout.pdf)","layout_type=native)","layouts,","lead","learn","leav","led","led(0)","led(1)","led).","led.","led.toggle()","left","legaci","len","len()","len(buf)","len(msg),","len)","length","length)","length.","less","less)","let","let'","letter,","let'","level","level,","level.","li","liability,","liabl","lib","lib)","lib.","lib_a.pi","librari","libraries)","libraries,","libraries.","libraries/tree/master/lib/sqnsupgrad","library\"","library,","library.","library;","library'","libusb","libusbk","licenc","licens","life","life,","life.","light","light_sensor","light_sensor.read()","light_sensor.read())","lights.","lightweight","like:","limit","limitations).","limitations,","limited.","line","line).","line,","line.","lines:","ling","link","link.","links.","linux","linux,","linux.","linux/macos)","linux:","lipo","lis2hh12","lis2hh12()","lis2hh12(pysens","lis2hh12(pytrack","lis2hh12)","lis2hh12.","lis2hh12.acceleration()","lis2hh12.pi","lis2hh12.pitch()","lis2hh12.roll()","list","list(net","list,","list.","listen","lists,","lite","littl","live","llvm","load","load)","local","local_tim","locals()","localtime()","localtime.","locat","located.","location.","location=20","lock","lock.","lock.acquire(waitflag=1,","lock.locked()","lock.release()","lock:","locks:","log","log,","logarithm","logic","login","login.","login=('micro',","long","long.","longer","longer.","longest","longitud","longitude/latitude,","look","lookup","loop","loop\")","loop)","loop,","loop/non","loopcount","loops,","loops.","loos","loosevers","lopi","lopy!","lopy!\")","lopy'","lopy,","lopy.","lopy4","lopy4,","lopy4.","lopy4:","lopy:","lopys.","lopy'","lora","lora()","lora(mode=lora.lora,","lora(mode=lora.lorawan)","lora(mode=lora.lorawan,","lora)","lora,","lora.","lora.abp","lora.abp.","lora.add_channel","lora.add_channel(index,","lora.add_channel(index=0,","lora.always_on,","lora.as923","lora.as923,","lora.au915","lora.au915,","lora.bandwidth()","lora.bandwidth([bandwidth])","lora.bandwidth(lora.bw_125khz)","lora.bw_125khz","lora.bw_125khz,","lora.bw_250khz","lora.bw_250khz,","lora.bw_250khz.","lora.bw_500khz","lora.bw_500khz.","lora.callback(trigger,","lora.callback(trigger=(lora.rx_packet_ev","lora.class_a","lora.class_a,","lora.class_c","lora.class_c.","lora.coding_4_5","lora.coding_4_5,","lora.coding_4_6","lora.coding_4_6,","lora.coding_4_7","lora.coding_4_7,","lora.coding_4_8","lora.coding_4_8.","lora.coding_rate()","lora.coding_rate([coding_rate])","lora.coding_rate(lora.coding_4_5)","lora.eu868","lora.eu868,","lora.events()","lora.events().","lora.frequency()","lora.frequency(868000000)","lora.frequency([frequency])","lora.has_joined()","lora.has_joined().","lora.has_joined():","lora.init(mode,","lora.init(mode=lora.lora,","lora.init(mode=lora.lorawan)","lora.init(mode=lora.lorawan,","lora.ischannel_free(","lora.ischannel_free(rssi_threshold)","lora.join(activation,","lora.join(activation=lora.abp,","lora.join(activation=lora.otaa,","lora.lora","lora.lora,","lora.lorawan","lora.lorawan.","lora.mac()","lora.mac().to","lora.nvram_erase()","lora.nvram_restore()","lora.nvram_save()","lora.otaa","lora.otaa,","lora.power_mode([power_mode])","lora.preamble()","lora.preamble([preamble])","lora.preamble(lora.coding_4_5)","lora.remove_channel()","lora.remove_channel(index)","lora.rx_packet_ev","lora.rx_packet_event,","lora.rx_packet_event:","lora.set_battery_level(127)","lora.set_battery_level(level)","lora.sf()","lora.sf(7)","lora.sf([sf])","lora.sleep","lora.sleep.","lora.sleep:","lora.stats()","lora.tx_failed_ev","lora.tx_onli","lora.tx_only,","lora.tx_packet_ev","lora.tx_packet_event),","lora.tx_packet_event,","lora.tx_packet_event:","lora.us915","lora.us915.","lora/sigfox","lora_cb(lora):","lora_confirm_format","lora_pkg_format","lora_region","lora_sock","lora_sock.recv(256)","lora_sock.recv(512)","lora_sock.recv(64)","lora_sock.send(ack_pkg)","lora_sock.send(msg)","lora_sock.send(pkg)","lora_sock.setblocking(false)","loraeu868.","lorawan","lorawan.","lose","lot","low","low.","lower","lower,","lowest","lpwan","lsusb","lt","lte","lte()","lte(carrier=\"verizon\")","lte).","lte.","lte.attach()","lte.attach(*,","lte.attach(band=13)","lte.connect()","lte.connect(*,","lte.connect(cid=3)","lte.deinit()","lte.dettach()","lte.disconnect()","lte.iccid()","lte.imei()","lte.init(*,","lte.isattached()","lte.isattached())","lte.isattached():","lte.isconnected()","lte.isconnected():","lte.reset()","lte.send_at_cmd('at!=\"addscanband","lte.send_at_cmd('at!=\"clearscanconfig\"')","lte.send_at_cmd('at!=\"disablelog","lte.send_at_cmd('at+cereg?')","lte.send_at_cmd('at+cfun=0')","lte.send_at_cmd('at+cfun=1')","lte.send_at_cmd('at+cgdcont=1,\"ip\",\"nb.inetd.gdsp\"')","lte.send_at_cmd('at+cgsn=1')","lte.send_at_cmd(cmd)","lte.send_at_cmd(cmd).split('\\r\\n')","ltr","ltr329als01","ltr329als01(py)","ltr329als01(pysens","ltr329als01.light()","ltr329als01.pi","lux","lux.","m","m']","m/nb","m1","m1,","m1/nb","m1:","m1nb","mac","mac_addr","machin","machine,","machine.adc()","machine.adc(id=0)","machine.brown_out_reset","machine.can(bus=0,","machine.dac('p21')","machine.dac('p22')","machine.dac(pin)","machine.deepsleep([time_ms])","machine.deepsleep_reset,","machine.disable_irq","machine.disable_irq()","machine.enable_irq","machine.enable_irq([state])","machine.freq()","machine.hard_reset,","machine.i2c(bus,","machine.idle()","machine.info()","machine.main(filename)","machine.pin(id,","machine.pin_deepsleep_wakeup(pins,","machine.pin_wake,","machine.pwm(timer,","machine.pwron_reset,","machine.pwron_wake,","machine.remaining_sleep_time()","machine.reset()","machine.reset_cause()","machine.rmt(channel,...)","machine.rmt(channel=2)","machine.rmt(channel=2,","machine.rmt(channel=3)","machine.rmt(channel=3,","machine.rng()","machine.rtc()","machine.rtc().datetime(tuple)","machine.rtc(id=0,","machine.rtc_wake,","machine.sd(id,","machine.soft_reset,","machine.soft_reset:","machine.spi(id,","machine.uart(0,","machine.uart(bus,","machine.ulp_wak","machine.unique_id()","machine.wake_reason()","machine.wakeup_all_low","machine.wakeup_all_low,","machine.wakeup_any_high","machine.wakeup_any_high.","machine.wdt(id=0,","machine.wdt_reset,","machine='gpi","machines,","maco","macos,","macos/linux","macos/linux:","macos:","macports:","macro","made","made.","magic","main","main.pi","main.py)","main.py.","main.py;","mainli","maintain","major","make","makefil","makefile()","makefile().","male","manag","manager'","manager.","mandat","mandatori","mandatory.","mani","manifest","manifest.json.","manipul","manner","mantissa","manual","manual,","manually.","manufactur","manufacturer_data","manufacturer_data=\"lopy_v1\")","manufacturer_data=none,","map","map()","mark","mask","mask).","master","master,","master.","master/slav","master:","match","match()","match,","match.group([index])","math","math.acos(x)","math.acosh(x)","math.asin(x)","math.asinh(x)","math.atan(x)","math.atan2(y,","math.atanh(x)","math.ceil(x)","math.copysign(x,","math.cos(x)","math.cosh(x)","math.degrees(x)","math.e:","math.erf(x)","math.erfc(x)","math.exp(x)","math.expm1(x)","math.fabs(x)","math.floor(x)","math.fmod(x,","math.frexp(x)","math.gamma(x)","math.isfinite(x)","math.isinf(x)","math.isnan(x)","math.ldexp(x,","math.lgamma(x)","math.log(x)","math.log10(x)","math.log2(x)","math.modf(x)","math.pi:","math.pow(x,","math.radians(x)","math.sin(x)","math.sinh(x)","math.sqrt(x)","math.tan(x)","math.tanh(x)","math.trunc(x)","mathemat","max","max()","max_split=","max_time_wait","maximum","maximum.","mbr","mcu","mcu/soc.","mcu_registers.peripheral_a.register1,","md5","mday","mday,","mean","meaning;","means:","meant","measur","measurement,","measurement_tim","measurement_time:","mechan","mechanism.","medium","memaddr,","memaddr.","member","memori","memory,","memory.","memoryerror","memoryview","memoryview(buffer)","memory'","mention","menu","merchantability,","merge,","mesh","messag","message'","message):","message,","message,\"done!\"","message.","message:","messages,","messages.","metadata","meter","meter.","method","method()","method)","method,","method.","method:","methodolog","methods,","methods.","methods:","mexico","mf","mfg_data","mfg_data:","mfrc630","mfrc630(py)","mfrc630(pyscan=none,","mfrc630.format_block(block,","mfrc630.mfrc630_cmd_idle()","mfrc630.mfrc630_cmd_init()","mfrc630.mfrc630_cmd_load_key(key)","mfrc630.mfrc630_cmd_load_key(key).","mfrc630.mfrc630_cmd_reset()","mfrc630.mfrc630_format_block(data,","mfrc630.mfrc630_iso14443a_select(uid)","mfrc630.mfrc630_iso14443a_wupa_reqa(instruction)","mfrc630.mfrc630_mf_auth(uid,","mfrc630.mfrc630_mf_deauth()","mfrc630.mfrc630_mf_read_block(block_address,","mfrc630.mfrc630_print_block(data,","mfrc630.mpi","mfrc630.print_debug(msg)","mfrc63002hn,","mfrc630_format_block","mfrc630_iso14443_cmd_reqa","mfrc630_iso14443_cmd_wupa,","mfrc630_mf_auth_key_b)","mfrc630_mf_deauth()","mhz","mhz)","mhz.","micro","micro),","micro.","microchip","micropygp","micropython","micropython,","micropython.","micropython.alloc_emergency_exception_buf(size)","micropython.const(expr)","micropython.heap_lock()","micropython.heap_unlock()","micropython.kbd_intr(chr)","micropython.mem_info([verbose])","micropython.opt_level([level])","micropython.qstr_info([verbose])","micropython.stack_use()","micropython:","micropython;","micropyton","microsd","microsecond","microsecond[,","microseconds,","microseconds.","microsoft","microsoft'","mifar","milisecond","millisecond","millisecond).","milliseconds)","milliseconds,","milliseconds.","millivolts)","millivolts,","min","min()","mind","mind,","minicom","minim","minimis","minimum","minimum.","minor","minor,","minut","minute,","minute[,","minutes,","mircopython","mirror","miscellan","miso","miso)","miso))","miso).","miso.","mistake,","mit","mobil","mobility.","mod","modbu","modbus_obj.read_coils(slave_addr,","modbus_obj.read_discrete_inputs(slave_addr,","modbus_obj.read_holding_registers(slave_addr,","modbus_obj.read_input_registers(slave_addr,","modbus_obj.write_multiple_coils(slave_addr,","modbus_obj.write_multiple_registers(slave_addr,","modbus_obj.write_single_coil(slave_addr,","modbus_obj.write_single_register(slave_addr,","mode","mode\")","mode)","mode).","mode,","mode.","mode...","mode:","mode;","mode=bluetooth.ble,","mode=can.normal,","mode=pin.in,","mode=pin.open_drain)","mode=pin.out)","mode=pin.out)(true)","mode=pin.out,","mode=spi.master,","model","modem","modem,","modem.","modes.","modes:","modes;","mode'","mode'.","modif","modifi","modification.","modified;","modify,","modul","modulate,","modulation.","module'","module)","module).","module):","module,","module.","module/accessori","module:","modules,","modules.","modules:","module'","modulu","moment.","mon","monarch","monitoring,","monitoring.","month","month,","more","more)","more,","more:","mosi","mosi,","motion","mount","mount(sd,","mount_point,","mounted,","mounted.","move","mpl3115a2","mpl3115a2(pysens","mpl3115a2.","mpl3115a2.altitude()","mpl3115a2.pressure()","mpl3115a2.temperature()","mqtt","mqtt.","mqtt]","mqtt_oper_timeout","mqttclient","mqttclient(\"device_id\",","mqttserviceaddress","ms","ms)","ms).","ms,","ms.","msg","msg)","msg))","msg):","msg=\"off\")","msg=\"on\")","msg[:16])","much","multipl","multipli","mutabl","mutex","mv","my_struct.substruct1.field1.","n","name","name\"","name,","name.","name=none,","names.","nano","narrow","nativ","natur","navig","nb","nb1","nbr_char","nbr_chars=1,","nbyte","nbytes)","nbytes,","nbytes])","near","nearest","necessari","necessarili","necessary,","necessary.","need","needed)","needed.","needs:","neg","negoti","negotiation...","nest","nested,","net","net.ssid","net_properti","net_properties:","net_properties['pwd']","net_to_us","net_to_use[0]","net_to_use][0]","nets\")","nets:","network","network,","network.","network.bluetooth(id=0,","network.lora(id=0,","network.lte(id=0,","network.serv","network.server()","network.server(id,","network.sigfox(id=0,","network.wlan(id=0,","network.wlan(mode=network.wlan.sta)","network.wlan.","networking.","networks.","networks:","never","new","new)","new,","new:","new_lib.pi","new_path)","newer","newer)","newli","newlin","next","next()","next_diff","nfc","nfc.mfrc630_cmd_init()","nfc.mfrc630_cmd_reset()","nist.","no_reset","node","nodej","nodejs.","nodename='gpy',","noexit","noexit`","nois","non","none","none)","none).","none):","none,","none.","noninfringement.","nonneg","nonzero","nonzero,","norm.","normal","normal,","normal.","normalis","normally,","not).","not.","notabl","notat","notation:","note","note,","note:","notes.","noth","notic","notif","notifi","notifications:","now","now,","ntp","ntp_sync","number","number,","number.","number1","number2","number2):","number:","number;","numbers.","numbers.\"","numer","nut.","nutshell,","nv","nvm","nvm).","nvram","nvram_sav","nvs,","nvs:","nwk_swkey","nwk_swkey,","nwpref","nwprefs]","nxp","obj","obj.","object","object)","object).","object,","object.","object;","objects.","object'","obligatori","obscur","obtain","obtained.","obvious","occupi","occur","occur,","occurs,","occurs.","oct()","oem","of.","of:","off\")","off.","off/on","off/on)","offend","offer","offic","offici","offline_queue_s","offset","offset,","offset.","offset=0)","often),","ohm","ok","ok.","old","older","oman","on","on\")","on),","on,","on.","on_the_fli","onboard","onc","once,","one,","one.","onewir","onewire(pin('p10'))","onewire:","ongo","only)","only),","only,","only.","onto","onward","onward,","open","open('/sd/gp","open('/sd/test.txt',","open()","open(appimg,","open)","open,","open.","open_drain","open_on_start","opened.","opened:","openmoko","oper","operations\".","operations')","operations).","operations.","operator,","opposit","optim","optimis","option","option,","option.","option;","optional.","options,","options:","optname,","or,","orang","ord()","order","order).","order:","ored):","organis","organise.","orient","origin","original_auth","original_ssid","os","os,","os.dupterm(uart)","os.listdir('/sd')","os.mkfs('/flash')","os.mkfs(sd)","os.mount(sd,","os.uname()","os/rto","oscil","ota","ota\")","ota.connect()","ota.update()","ota_0","ota_0,","ota_finish","ota_finish()","ota_finish().","ota_start()","ota_start(),","ota_start,","ota_write(buffer),","ota_write(mv[:chunk])","ota_write,","otaa","otadata,","other","other);","other,","others,","otherwis","otherwise,","otherwise.","otherwise:","ourselv","out","out!\")","out.","outdoor","outlin","outperform","output","output,","output.","output:","output_address,","output_address=0x00","output_flag","output_flag)","output_value)","output_value=0xff00","output_values)","output_values=[1,1,1,0,0,1,1,1,0,0,1,1,1]","outsid","over","overflow","overhead","overhead,","overridden","overview","overwritten","ow","own","owner.","p","p,","p.","p10","p10,","p11=scl)","p12","p12,","p13","p13,","p14","p14,","p15,","p16","p16,","p17,","p18","p18,","p18.","p19,","p2,","p20,","p20.","p21","p21,","p21.","p22","p22,","p23","p23.","p23:","p3,","p4,","p4:","p6","p6,","p6.","p8","p8,","p8/g15","p8:","p9","p9,","p_in","p_in()","p_in.callback(pin.irq_fal","p_out","p_out(true)","p_out.toggle()","p_out.value(0)","p_out.value(1)","pac","pac.","pack","packag","package)","package,","package.","package:","packaging),","packet","packet.","packets).","packets.","pacman","pad,","page","page,","page.","page:","pages:","pair","pair.","pairing.","pane","pane,","pane/bottom","panel","panel,","parallel","param","paramet","parameter.","parameters)","parameters,","parameters.","parameters:","parameters]","pariti","parity,","parity=none,","pars","parser","part","parti","particular","particular,","particularli","partit","partition,","partition]","partitions,","pass","passed\"","passed.","passes.","passiv","password","password)","password),","password,","password.","password:","password=\"your_api_key\",","past","path","path)","path):","path,","path.","paths.","pattern","pattern.","paus","payload","payload,","payloaddict","pc","pc.","pcb","pdf","peap","peculiar","peer","per","percent","percentag","perform","perform.","performed.","period","period).","period=150):","periodic:","periodic=false)","periodic=true)","periods.","peripher","peripheral,","peripheral_a.register0.","peripheral_a.register1.","peripheral_a.register[0]","peripherals,","perman","permanently.","permiss","permissions,","permit","persist","persistent,","person","personal,","personalis","personalisation)","personalisation.","personalization)","pertain","phase","phase=0)","phase=0,","phi","phi)","phi.","philosophi","phone/tablet),","phone/tablet/pc).","phones,","phr","phrase.","physic","pi,","pic","pic]","pic_rc1","pic`","pick","picocom","picocom,","pictur","pid),","piec","pig","pin","pin#6","pin(\"g7\",","pin('g16',","pin('g4',mode=pin.in,","pin('p10',","pin('p12',","pin('p9',","pin()","pin(0)","pin(1)","pin([value])","pin(pin.exp_board.g16,","pin(pin.module.p9,","pin),","pin):","pin,","pin.","pin.callback(trigger,","pin.exp_board","pin.exp_board.g16","pin.exp_board.g16.id()","pin.hold([hold])","pin.id()","pin.in","pin.in,","pin.init()","pin.init(mode,","pin.irq_fal","pin.irq_high_level","pin.irq_low_level","pin.irq_ris","pin.irq_rising,","pin.mode([mode])","pin.modul","pin.module.p9","pin.module.p9.id()","pin.open_drain","pin.out","pin.out,","pin.pull([pull])","pin.pull_down","pin.pull_up","pin.pull_up)","pin.pull_up,","pin.toggle()","pin.value()","pin.value([value])","pin:","pin='p12')","pin='p12',","pin='p16'","pin_handler(arg):","pin_handler)","pinout","pinouts,","pins.","pins/min","pins=('p10','p11'))","pins=('p12',","pins=('p19','p20','p21'))","pins=('p20',","pins=('p20','p21'))","pins=('p22',","pins=(clk,","pins=(sda,","pins=(txd,","pins=none,","pir","pir()","pitch","pkcs8","pkg","pkg:","pkg_len,","place","place.","placement","plain","plaintext","plan","platform","platform,","platform.","platforms).","platforms:","pleas","plug","plugging/unplug","plugin","plugin,","plugin.","plugin:","po","point","point,","point.","pointer","pointer,","points.","polar","polarity=0,","polici","poll","poll.modify(obj,","poll.poll([timeout])","poll.register(obj[,","poll.unregister(obj)","polling.","popul","popular","port","port)","port),","port,","port.","port/user).","port:","port=1883)","port]","port`","portabl","portable.","portal","portal,","portal.","portion","ports).","ports,","ports.","posit","position:","positional;","positions,","positive,","posix","possibl","possible.","post","post.","potenti","pow()","power","power!!!)","power!!!)................","power!!!)............................................................................","power),","power).","power,","power_mod","power_mode=lora.always_on,","power_sav","power_save=false,","practic","pre","preambl","preamble=8,","preced","precis","precision,","precision.","precompil","preconfigur","predefin","prefer","preference.","prefix","prefixes:","prepar","prerequisit","presenc","presence\")","present","present,","present.","present:","preserv","press","pressed.","pressur","pressure)","pressure,","pretti","prevent","previou","previous","previous_version:","previously.","primari","primarili","primit","princip","print","print(\"","print(\"%02d","print(\"\\nth","print(\"\\r%7d","print(\"a_lock","print(\"ack\")","print(\"approxim","print(\"client","print(\"connect","print(\"delet","print(\"deveui:","print(\"error","print(\"exit","print(\"fail","print(\"from","print(\"got","print(\"hello","print(\"http","print(\"messag","print(\"no","print(\"perform","print(\"pin","print(\"pow","print(\"pres","print(\"property:","print(\"receiv","print(\"request","print(\"scan","print(\"send","print(\"start","print(\"tim","print(\"too","print(\"upd","print(\"version:","print(\"wakeup","print(\"writ","print(\"{}","print('\\nrtc","print('adjust","print('attaching...')","print('aw","print('can","print('char","print('coil","print('connecting...')","print('device:","print('hold","print('input","print('lora","print('network","print('not","print('read","print('run","print('wlan","print('writ","print('{},{}'.format(pitch,","print()","print(1","print(adc_c.voltage())","print(address_book['alex'])","print(binascii.hexlify(sigfox.id()))","print(binascii.hexlify(sigfox.pac()))","print(bluetooth.get_adv())","print(bluetooth.resolve_adv_data(adv.data,","print(data)","print(e)","print(line)","print(lt.light())","print(message.payload)","print(message.topic)","print(msg)","print(networks[2])","print(original)","print(pycom_devices[0])","print(rtc.now())","print(s.recv(4096))","print(s.recv(64))","print(service.uuid())","print(services)","print(temp.read_temp_async())","print(ubinascii.hexlify(lora.mac()).upper().decode('utf","print(ubinascii.hexlify(mfg_data))","print(ubinascii.hexlify(sigfox.mac()))","print(value)","print(variable)","print(wake_s)","print(welcome_phrase)","print(wlan.ifconfig())","print(x)","printed.","printing:","prior","privaci","privat","prlen","problem","proce","procedur","procedure).","procedure.","procedure:","proceeding:","process","process,","process.","process:","processor","produc","product","product,","products,","products.","profil","program","program,","program.","programat","programming.","progress.","prohibited).","project","project).","project,","project.","project:","projects,","projects.","prompt","prompt).","prompt,","prompt.","proper","properli","properti","properties,","properties.","property()","protect","protected)","proto,","protocol","protocol,","protocol.","protocols.","protocols:","prototyping.","prove","provid","provided,","provided.","provider.","provis","provisioning.","pseudo","ptr","public","public,","public=false)","public=true)","public=true,","public_key","publish","publish,","pull","pull,","pull.","pull=none,","pull=pin.pull_up)","puls","pulse,","pulse.","pulse:","pulses,","pulses.","pulses_get","pulses_get(pin,","purpos","purpose.","purposes.","push","put","putti","putty.","pwd","pwd),","pwd]","pwm","pwm(0,","pwm.channel()","pwm.channel(0,","pwm.channel(id,","pwm_c","pwm_c.duty_cycle(0.3)","pwmchannel","pwmchannel.","pwmchannel.duty_cycle(value)","py","py,","py.go_to_sleep()","py.setup_int_pin_wake_up(false)","py.setup_int_wake_up(true,","py.setup_sleep(300)","pyabcde0","pyb.uart,","pyb.usb_vcp.","pyb:","pyboard","pybyt","pybytes).","pybytes,","pybytes.","pybytes.send_virtual_pin_valu","pybytes.send_virtual_pin_value(persistent,","pybytes:","pybytes;","pybytes?","pybytes_config.json","pycas","pycase,","pycod","pycom","pycom'","pycom.","pycom.heartbeat()","pycom.heartbeat([enable])","pycom.heartbeat(false)","pycom.heartbeat(true)","pycom.heartbeat_on_boot([enable])","pycom.io\\r\\nauthorization:","pycom.nvs_erase(key)","pycom.nvs_erase_all()","pycom.nvs_get('count')","pycom.nvs_get(key)","pycom.nvs_set('count',","pycom.nvs_set('temp',","pycom.nvs_set(key,","pycom.ota_finish()","pycom.ota_slot()","pycom.ota_start()","pycom.ota_write(buffer)","pycom.pulses_get()","pycom.pulses_get(pin,","pycom.rgbled(0x0000ff)","pycom.rgbled(0x001500)","pycom.rgbled(0x007f00)","pycom.rgbled(0x00ff00)","pycom.rgbled(0x150000)","pycom.rgbled(0x7f0000)","pycom.rgbled(0x7f7f00)","pycom.rgbled(0xff00)","pycom.rgbled(0xff0000)","pycom.rgbled(color)","pycom.rgbled(color=0xff0000)","pycom.rgbled(rgb_blue)","pycom.rgbled(rgb_green)","pycom.rgbled(rgb_red)","pycom.wdt_on_boot()","pycom.wdt_on_boot([enable])","pycom.wdt_on_boot(true)","pycom.wdt_on_boot_timeout()","pycom.wdt_on_boot_timeout(10000)","pycom.wdt_on_boot_timeout([timeout])","pycom.wifi_on_boot()","pycom.wifi_on_boot([enable])","pycom.wifi_on_boot(true)","pycom/pycom","pycom_devic","pycomawsmqttcli","pycomawsmqttclient.configureconnectdisconnecttimeout(config.conn_disconn_timeout)","pycomawsmqttclient.configurecredentials(config.aws_root_ca,","pycomawsmqttclient.configuredrainingfrequency(config.draining_freq)","pycomawsmqttclient.configureendpoint(config.aws_host,","pycomawsmqttclient.configurelastwill(config.last_will_topic,","pycomawsmqttclient.configuremqttoperationtimeout(config.mqtt_oper_timeout)","pycomawsmqttclient.configureofflinepublishqueueing(config.offline_queue_size)","pycomawsmqttclient.connect():","pycomawsmqttclient.subscribe(config.topic,","pycomawsmqttshadowcli","pycomawsmqttshadowclient.configureconnectdisconnecttimeout(config.conn_disconn_timeout)","pycomawsmqttshadowclient.configurecredentials(config.aws_root_ca,","pycomawsmqttshadowclient.configureendpoint(config.aws_host,","pycomawsmqttshadowclient.configuremqttoperationtimeout(config.mqtt_oper_timeout)","pycomawsmqttshadowclient.connect():","pycomawsmqttshadowclient.createshadowhandlerwithname(config.thing_name,","pycom'","pycoproc.pi","pycrypto.","pymakr","pymakr,","pymakr.","pymakr.conf","pymakr.conf.","pymakr;","pymakr@1.0.3)","pyscan","pyscan()","pyscan.","pyscan'","pysens","pysense()","pysense),","pysense).","pysense,","pysense.","pysense.pi","pysense/pytrack","pysense/pytrack/expans","pysense/pytrack/pyscan","pysense/pytrack/pyscan.","pysense/pytrack/pyscan/expans","pysense:","pysense_x.x.x.dfu","pysense'","pyseri","python","python,","python.","python3","python3.","pytrack","pytrack'","pytrack()","pytrack,","pytrack.get_sleep_remaining()","pytrack.get_wake_reason()","pytrack.go_to_sleep([gps=true])","pytrack.setup_int_pin_wake_up([rising_edg","pytrack.setup_int_wake_up(rising,","pytrack.setup_sleep(time_seconds)","pytrack.setup_sleep(timout_sec).","pytrack/pysens","pytrack/pysense,","pytrack/pysense/pyscan.","pytrack/pysense/pyscan/expans","pytrack:","pytrack_0.0.8.dfu","pytrack_0.0.8.dfu):","pytrack'","q","q,","q.","q]","quantiti","queri","queu","queue","queue,","queue.","quick","quickli","quiescent","quiet","quiet`","quit","quot","r","r,","r]","r_b","ra5).","race\"","racer","rad","radian","radians.","radio","radio.","rais","raised.","ram","ram.","random","randomli","rang","range()","range(0,","range(0xff):","range(1,","range(10):","range(2):","range(3):","range(8):","range(len(data)):","range,","range.","rate","rate'","rate':","rate.","rate:","ratio","raw","rbuf","rbuf)","rc1,","rcz","rcz1","rcz2","rcz3","rcz4","rcz4.","rcz=sigfox.rcz1)","rcz=sigfox.rcz1,","re","reach","read","read()","read(self):","read,","read.","read/writ","read_bit(self):","read_buf)","read_buf.","read_byte(self):","readabl","reader","reader:","readers.","readi","reading.","readonly=false)","ready,","ready.","real","realli","reason","reason,","reason.","reason:","reboot","reboot.","reboots,","reboots.","receiv","receive,","received')","received,","received.","received...","receiver.","receiving,","recent","reception.","recipient'","recognis","recommend","recommended.","reconfigur","reconnect","reconnect.","record.txt',","recov","recover","recovered.","recoveri","recurs","recv_ack","recv_ack)","recv_data","recv_data)","recv_pkg","recv_pkg)","recv_pkg[1]","recv_pkg_len","recv_pkg_len,","recycl","red","red,","reduc","refer","referenc","reference,","reference.","referenced.","reflash","refus","regard","regardless","regex","regex.match(string)","regex.search(string)","regex.split(string,","region","region)","region=lora.eu868)","region=lora.us915)","region]","regions:","regist","register.","register/manag","register_address,","register_address=0x01","register_quantity,","register_quantity=100","register_valu","register_value))","register_value,","register_value=","register_values,","register_values=[2,","registered,","registers)","registers,","registers.","registr","registration\";","registration,","registration.","registri","regul","regular","regularli","reinstal","rejected!\")","rel","relat","releas","release='1.17.0.b1',","released.","relev","reli","reliabl","reload","remain","remaind","remaining:","remap","rememb","remot","remotely.","remov","remove()","removed,","renam","repeat","repeat.","repeatedli","repetit","repl","repl)","repl,","repl.","repl:","replac","replay","repli","repo.","report","reposit","repositori","repository.","repr()","repres","represent","representation.","represents:","republish","reqa.","request","request\")","request.","request/repli","requests.","requir","require.","required),","required.","resend","reset","reset\")","reset(self):","reset).","reset,","reset.","reset;","reset`","resets,","resets.","resid","resistor","resistor.","resistor:","resiz","resolut","resolution,","resolution:","resolv","resolve_adv_data()","resourc","respect","respectively.","respond","respond.","respons","response.","response:","responsestatu","responsestatus,","rest","restart","restor","restrict","restriction,","result","result.","result:","results.","resum","retain","retri","retriev","return","return_cod","return_flag","returned).","returned.","returning.","returns,","returns:","reus","reused.","reversed()","revert","review","rf","rfid","rfid/nfc","rgb","rgb_bright","rgb_red","rgbled.","right","rightmost","rippl","rise","risk","rmt","rmt(channel=4,","rmt.","rmt.deinit()","rmt.high","rmt.high))","rmt.init()","rmt.init(gpio,","rmt.init(gpio=\"p20\",","rmt.init(gpio=\"p21\",","rmt.low,","rmt.low.","rmt.pulses_get()","rmt.pulses_get(pulses,","rmt.pulses_get(pulses=100)","rmt.pulses_get(timeout=500)","rmt.pulses_send(duration,","rmt.recv_pulses()","rmt.send_pulses(duration,","rn2483","robot","role","roll","roll))","roll,","rom","rom):","rom,","rom0","rom:","root","round","round()","rout","router","router.eu.thethings.network).","row","rsa","rsaprivatekey\"","rssi","rssi).","rssi,","rssi_threshold","rst","rt","rtc","rtc()","rtc(id=0)","rtc,","rtc.","rtc.init((2014,","rtc.init((2017,","rtc.init()","rtc.init(datetime)","rtc.init(datetime=(2014,","rtc.init(datetime=none,","rtc.internal_rc","rtc.internal_rc,","rtc.now()","rtc.now())","rtc.now()))","rtc.now(),","rtc.ntp_sync(\"pool.ntp.org\")","rtc.ntp_sync(server,","rtc.synced()","rtc.xtal_32khz","rtm","rtos),","rtr","rtr,","rtr=false,","rtr=true)","rts,","rts/ct","rtu","rtu).","rule","rule.","run","run).","run,","run/sync","run:","running,","running:","runs.","runtim","runtimeerror","rx","rx/tx","rx:',","rx_filter_threshold","rx_filter_threshold,","rx_filter_threshold=20)","rx_idle_threshold","rx_idle_threshold,","rx_idle_threshold.","rx_idle_threshold=1000)","rx_idle_threshold=1000,","rx_idle_threshold=12000)","rx_iq","rx_iq=false,","rx_iq=true,","rx_queue_len","rx_queue_len=128,","rx_timestamp","rxd","rxd,","s","s,","s.bind(1)","s.close()","s.connect((self.ip,self.port))","s.connect(socket.getaddrinfo('www.google.com',","s.connect(socket.getaddrinfo('www.micropython.org',","s.recv(128)","s.recv(32)","s.recv(64)","s.recvfrom(128)","s.send('')","s.send('devic","s.send('hello","s.send('hello')","s.send('ping')","s.send('pong')","s.send(b\"get","s.send(bytes([0x01,","s.send(bytes([0x04,","s.send(bytes([1,","s.setblocking(false)","s.setblocking(true)","s.setsockopt(socket.sol_lora,","s.setsockopt(socket.sol_sigfox,","s.settimeout(5.0)","s.settimeout(5.5)","s1","safe","safe_boot_on_upload","same","sampl","sample.","save","save.","saved.","scalabl","scalar","scale","scale.","scan","scan(self):","scanned.","scanning.","schemat","scheme","schmidt","schmidt,","sck","sck,","scl","scl)","scl))","scl='p21',","sclk","screen","screen,","screen.","screen:","screw","script","script,","script.","script/program","scripts,","scripts.","scripts:","scroll","sd","sd()","sd.deinit()","sd.init()","sd.init(id=0)","sda","sda,","sda='p22',","search","search()","search/navig","seat","sec","sec\")","sec,","second","second,","second[,","secondli","secondly,","seconds)","seconds,","seconds.","secret","section","section,","section.","sections.","secur","secure=on","secure_boot","secure_boot_signing_key.pem","secure_key=secure_boot_signing_key.pem","secureboot","secureboot,","security.","security:","see","seem","seen","segment","segment_s","segment_size)","select","select.poll()","select.poll*","select.pollerr","select.pollhup","select.pollin","select.pollout","select.pollout.","select.select(rlist,","select_rom(self,","selected,","selected.","self.__alarm","self._search_rom(rom,","self.addr","self.bas","self.i2c","self.i2c.readfrom(self.addr,","self.i2c.writeto(addr,","self.ip","self.period","self.pin","self.pin.init(pin.open_drain,","self.port","self.read_bit()","self.read_bit():","self.reset()","self.reset():","self.second","self.seconds)","self.sendrequest(\"type=command¶m=switchlight&idx=\"+idx+\"&switchcmd=\"+command)","self.sendrequest(\"type=command¶m=updateuservariable&vtype=0&vname=\"+name+\"&vvalue=\"+value)","self.tim","self.valu","self.write_byte(b)","self.write_byte(cmd_matchrom)","self.write_byte(cmd_searchrom)","self.write_bytes(rom)","sell","semant","semaphores)","semtech","send","send.","send_at_cmd_pretty('at!=\"fsm\"')","send_at_cmd_pretty('at!=\"showphy\"')","send_at_cmd_pretty(cmd):","sending/receiv","sending/receiving.","sendrequest(self,","senet","sens","sensibl","sensing.","sensor","sensor)","sensor,","sensor.","sensor:","sensors.","sensors_data","sent","sent')","sent,","sent/receiv","sep","sep])","separ","sequan","sequenc","sequenti","sequentially,","ser=py343434","seri","serial","serial,","serial.","serial:","serialport","serv","server","server(login=('user',","server)","server).","server,","server.","server.deinit()","server.init(*","server.init(login=('user',","server.isrunning()","server.timeout()","server.timeout(300)","server.timeout([timeout_in_seconds])","server_ip","server_ip,","server_side=false,","servers.","server'","servic","service.","service.characteristic('temp',","service.characteristic(uuid,","service.characteristics()","service.instance()","service.isprimary()","service.start()","service.stop()","service.uuid()","service.uuid())","service_data","service_data=none,","service_uuid","service_uuid=b'1234567890123456')","service_uuid=none)","services,","services.","services:","services​","session","session,","session.","set","set,","set.","set:","set_advertisement()","set_pullups).","setattr()","setlight(self,","setsockopt()","settimeout()","settings!!","settings,","settings.","settings:","setup","setup,","setup_sleep()","setvariable(self,","sever","sf","sf7","sf=12)","sf=7,","sfrx","sfrx,","sftx","sftx,","sha","sha1","shadow","shall","shape","share","sheets,","shell.","shield","shield\"","shield,","shield.","shields,","shields.","shift","shifting,","shipped,","shock","short","short.","shortcut","shorter","shortest","shorthand","shortly.","shouldn't","show","showing.","shown","shutdown","si7006a20","si7006a20(pysens","si7006a20.","si7006a20.humidity()","si7006a20.temperature()","side","side,","side.","sidebar)","sidebar,","sides.","sigfox","sigfox(mode=sigfox.fsk,","sigfox(mode=sigfox.sigfox,","sigfox).","sigfox,","sigfox.","sigfox.frequencies()","sigfox.fsk","sigfox.fsk.","sigfox.id()","sigfox.init(mode=sigfox.sigfox,","sigfox.mac()","sigfox.pac()","sigfox.public_key()","sigfox.public_key([public])","sigfox.public_key(true)","sigfox.rcz1,","sigfox.rcz2,","sigfox.rcz3,","sigfox.rcz4","sigfox.rcz4.","sigfox.rssi()","sigfox.sigfox","sigfox.sigfox,","sigfox.sigfox.","sign","signal","signal'","signal,","signal.","signals,","signals.","signatur","signature_verification_key.bin","signed)","signed=tru","signific","silent","silently.","sim","sim.","similar","similar.","simpl","simplest","simpli","simplifi","simul","simultan","sine","singapore,","singl","sinwav","sipi","sipy,","sipy.","sipy:","sit","site","site.","situations.","size","size)","size,","size.","size/byt","size=0","sizes.","sketch","skill","slave","slave,","slave.","slave_addr=0x0a","sleep","sleep(5)","sleep)","sleep.","sleep_m","sleep_ms()","sleep_ms(20)","sleep_u","sleep_us()","sleep_us(1)","sleep_us(40)","sleep_us(420)","sleep_us(480)","sleep_us(60)","slightli","slot","slot.","slowly.","sm","sma","smac","small","smaller","smallest","smart","sms.","sn65hvd230.","snif","snippet","snippet:","snr","snr,","so,","so:","sock","sock.setblocking(false)","sock.setblocking(true)","sock.settimeout(0.0)","sock.settimeout(none)","sockaddr)","socket","socket).","socket,","socket.","socket.accept()","socket.af_inet,","socket.af_lora","socket.bind(address)","socket.bind(port_number)","socket.close()","socket.connect(address)","socket.error,","socket.getaddrinfo().","socket.getaddrinfo(host,","socket.ipproto_tcp","socket.ipproto_tcp)","socket.ipproto_udp,","socket.listen([backlog])","socket.makefile(mode='rb')","socket.read(size)","socket.readall()","socket.readall(),","socket.readinto(buf[,","socket.readline()","socket.recv(bufsize)","socket.recvfrom(bufsize)","socket.send(bytes)","socket.send(bytes).","socket.sendall(bytes)","socket.sendto(bytes,","socket.setblocking(flag)","socket.setsockopt(level,","socket.settimeout(value)","socket.so_bit","socket.so_bit,","socket.so_confirmed,","socket.so_dr","socket.so_dr,","socket.so_oob,","socket.so_reuseaddr","socket.so_rx,","socket.so_tx_repeat,","socket.sock_dgram,","socket.sock_raw","socket.sock_raw)","socket.sock_stream,","socket.socket()","socket.socket(socket.af_inet,","socket.socket(socket.af_lora,","socket.socket(socket.af_sigfox,","socket.socket,","socket.sol_lora,","socket.sol_sigfox","socket.sol_socket,","socket.timeout","socket.write(buf)","socket:","sockets,","sockets.","soft","softwar","software,","software.","solder","solution!","solution:","some_asset.txt","some_library.pi","someth","sometim","somewher","soon","soon.","sort","sorted()","sourc","source,","source.","source:","source=rtc.internal_rc)","sources.","sources:","south","space","space.","span","spans.","spawn","spec","special","specif","specifi","specific,","specific.","specification:","specified,","specified.","spectrum,","speed","speed,","speed.","speed]","speed`","sphinx","spi","spi(0,","spi,","spi.deinit()","spi.init(mode,","spi.lsb","spi.lsb.","spi.mast","spi.master.","spi.msb","spi.read(5)","spi.read(nbytes,","spi.readinto(buf,","spi.write(buf)","spi.write(bytes([0x01,","spi.write_readinto(bytes([0x01,","spi.write_readinto(write_buf,","split","spread","sqnsupgrad","sqnsupgrade.run('/sd/catm1","sqnsupgrade.run('/sd/nb1","sqnsupgrade.run('serial_port',","sqnsupgrade.uart()","sqnsupgrade.uart(true)","sqnsupgrade.uart(true,'/flash/updater.elf')","squar","srv1","srv1.characteristic(uuid=b'ab34567890123456',","ss","ss.connect(socket.getaddrinfo('cloud.blynk.cc',","ss.connect(socket.getaddrinfo('www.google.com',","ssid","ssid',","ssid,","ssid.","ssid:","ssid:gpi","ssid='wipi","ssid=none,","ssid=original_ssid,","ssid]","ssl","ssl.cert_none,","ssl.cert_optional,","ssl.cert_required:","ssl.sslerror","ssl.sslsocket,","ssl.wrap_socket().","ssl.wrap_socket(s)","ssl.wrap_socket(s,","ssl.wrap_socket(sock,","ssl:","ssleay","st","st_atime:","st_ctime:","st_dev:","st_gid:","st_ino:","st_mode:","st_mtime:","st_nlink:","st_size:","st_uid:","sta","stabl","stack","stack.","stand","standard","standard)","standard.","standardis","standards.","start","start,","start.","start=true)","start_level","start_level)","start_level=rmt.high)","started!","started,","started.","started:","starting,","starting_address,","starting_address=0x0","starting_address=0x00","state","state(2)","state.","statement","statement,","static","static.ex","staticmethod()","station","station:","statu","status(0)","status,","status.split(\"","status:","stay","stefan","step","step,","step:","steps:","still","stop","stop=1)","stop=1,","stop=true)","stopwatch.","storag","storage.","store","store,","store/manag","store:","stp","str","str(i))","str(loopcount)","str(payloaddict[\"state\"][\"desired\"][\"property\"]))","str(payloaddict[\"state\"][\"property\"]))","str(payloaddict[\"version\"]))","str(py.get_sleep_remaining())","str(py.get_wake_reason()))","str(s.readline(),","straight","straightforward","stream","stream.","stream/connect","streamlin","strength","strictli","string","string)","string,","string.","strings,","strings.","strong,","strongli","struct","struct.pack(_lora_pkg_ack_format,","struct.pack(_lora_pkg_format","struct.pack(lora_pkg_format,","struct.unpack(\">l\",","struct.unpack(_lora_pkg_ack_format,","struct.unpack(_lora_pkg_format","struct.unpack(lora_confirm_format,","structur","structure\"","structure.","structure:","structures)","structures).","structures.","structures:","stuck","studio","style","sub","sub_cb(topic,","subclasses:","subject","sublicense,","subnet,","subnet_mask,","subscib","subscrib","subscript","subsequ","subset","substanti","substitut","substr","subsystem","subsystem.","subtract","subtyp","succe","succeed.","succeeded!')","succeeded')","succeeded.","succeeds.","success","success.","successful,","successfulli","successfully,","such","sudo","sudo)","sudo.","suffici","suggest","suggests).","suit","suitabl","suitable.","sum","sum()","summari","sun","super","super()","suppli","supplied)","supplied,","support","support).","supported.","suppress","sure","surround","swapping.","switch","sy","symbol","symbols.","symmetr","sync","sync.","sync_file_typ","sync_fold","synced,","synchronis","synchronisation,","syntax","syntax,","syntax.","sys.argv:","sys.byteorder:","sys.exit()","sys.exit(retval=0)","sys.implement","sys.implementation:","sys.maxs","sys.maxsize:","sys.modules:","sys.path:","sys.platform:","sys.print_exception(exc,","sys.stderr:","sys.stdin:","sys.stdout","sys.stdout:","sys.version:","sys.version_info:","system","system\"","system,","system.","system/micropython","system;","systemexit","systemexit.","system'","t","tab","tab,","tab.","tab;","tabl","table.","tail","taiwan,","take","taken","taken,","tale","talk","tangent","tar","tar,","tar[.gz]","tar]","target","target:","target=[boot|app]","target=app","target=boot","task","tasks)","tasks,","tcp","tcp)","technic","technolog","technology.","telemetri","tell","telnet","telnet,","telnet.","telstra","temp","temp.start_conversion()","temp_lsb","temp_read","temperatur","temperature,","temperature.","termin","terminal,","terminal/atom","terminal:","terminology)","terms.","test","test.","test:","text","text.","th_func(delay,","that,","that.","that'","thekeyfil","them,","them.","there!","there'","therefor","therefore,","there'","the“instal","thing","thing.","things'","things.","things:","third","this,","this.","this:","this_script.pi","those","though","thousand","thread","thread,","thread.","threads,","threads.","three","threshold","through","throughput","throughput.","thu","tick","ticket","ticks_*()","ticks_cpu().","ticks_diff()","ticks_m","ticks_ms()","ticks_ms(),","ticks_us()","ticks_us(),","ticks_us,","tilt","time","time,","time.","time.sleep(.5)","time.sleep(0.050)","time.sleep(0.1)","time.sleep(0.25)","time.sleep(0.5)","time.sleep(1)","time.sleep(1.25)","time.sleep(1.5)","time.sleep(2)","time.sleep(2.5)","time.sleep(4)","time.sleep(5)","time.sleep(delay)","time.sleep(machine.rng()","time.sleep_ms(100)","time.sleep_ms(50)","time.sleep_ms(500)","time.sleep_u","time.ticks_diff(start,","time.ticks_us()","time.ticks_us())","time.time()","time.timezon","timeout","timeout)","timeout,","timeout.","timeout:","timeout=","timeout=0)","timeout=10000)","timeout=30)","timeout=300)","timeout=5000)","timeout=60)","timeout=600)","timeout=none,","timeout])","timeout_char","timeout_chars=2,","timeout_m","timeouterror","timer","timer.","timer.alarm(handler=none,","timer.alarm(self._seconds_handler,","timer.chrono()","timer.sleep_us()","times.","timestamp","timezon","timezone',","timezone,","timezone.","tinker","tip","tls:","to,","to.","to/from","to:","togeth","together,","together.","toggl","toggled.","token","token):","token.","token:","token]","tolerant,","tone","too).","too,","too.","took","tool","tool,","tool.","tools,","tools/featur","top","topbar.","topic","topic,","topic:","topics.","tormod","tort","total","total)","touch","toward","trace","traceback","traceback.print_exception(),","track","tracking,","traffic","transact","transaction).","transaction:","transceiv","transfer","transfer,","transfer.","transform","transit","translat","transmiss","transmission.","transmissions,","transmissions.","transmit","transmitted.","transport","transport.","trash","travel","treat","tree.","tri","trials,","triangl","trick","trigger","trigger,","trigger=can.rx_fram","trigger=can.rx_frame)","trigger=pin.irq_fal","triggered.","trivial","troubleshoot","true","true)","true,","true.","true/false.","true:","true])","truncat","try:","ttls),","ttls:","ttn","ttn.","ttyusb.","tupl","tuple).","tuple,","tuple.","tuple:","tuples,","turn","tutori","tutorial.","tutorials,","tutorials.","two","two'","two.","tx","tx,","tx/rx,","tx:","tx_carrier","tx_carrier)","tx_counter","tx_counter,","tx_frequenc","tx_frequency)","tx_idle_level","tx_idle_level,","tx_idle_level=0)","tx_idle_level=rmt.low)","tx_idle_level=rmt.low,","tx_iq","tx_iq=false,","tx_iq=true,","tx_onli","tx_power","tx_power,","tx_power.","tx_power=14,","tx_retri","tx_retries=1,","tx_time_on_air","tx_time_on_air,","tx_trial","tx_trials,","txd","txd,","txd.","txt,","ty","type","type()","type(service.uuid())","type,","type.","type:","typed.","typeerror:","types,","types.","types:","typic","tzinfo","tzinfo]]]]])","u","u.fl","uart","uart(1,","uart.","uart.any()","uart.deinit()","uart.even","uart.even,","uart.init(9600,","uart.init(baudrate=9600,","uart.odd","uart.odd.","uart.read(10)","uart.read(5)","uart.read([nbytes])","uart.readall()","uart.readinto(buf)","uart.readinto(buf[,","uart.readline()","uart.rx_ani","uart.sendbreak()","uart.wait_tx_done(timeout_ms)","uart.write('abc')","uart.write('hello')","uart.write(buf)","uart/usart","uart1","uart2","uart_1","ubinascii","ubinascii.a2b_base64(data)","ubinascii.b2a_base64(data)","ubinascii.hexlify()","ubinascii.hexlify(adv.mac)","ubinascii.hexlify(b'12345')","ubinascii.hexlify(data[,","ubinascii.hexlify(hash.digest())","ubinascii.unhexlify('00000005'))[0]","ubinascii.unhexlify('00112233445566778899aabbccddeeff')","ubinascii.unhexlify('00250c0000010001')","ubinascii.unhexlify('11b0282a189b75b0b4d2d8c7fa38548b')","ubinascii.unhexlify('2b7e151628aed2a6abf7158809cf4f3c')","ubinascii.unhexlify('70b3d57ed0008cd6')","ubinascii.unhexlify('ada4dae3ac12676b')","ubinascii.unhexlify('b57f36d88691cec5ee8659320169a61c')","ubinascii.unhexlify(data)","ubuntu","ucrypto","ucrypto.aes(key,","ucrypto.decrypt()","ucrypto.encrypt()","uctyp","uctypes.addressof(),","uctypes.addressof(obj)","uctypes.bfuint16","uctypes.big_endian","uctypes.bytearray_at(addr,","uctypes.bytes_at(addr,","uctypes.little_endian","uctypes.n","uctypes.sizeof(struct)","uctypes.struct()","uctypes.struct(addr,","uctypes.uint32","uctypes.uint8","uctypes.uint8),","udp","ue","uhashlib","uhashlib.md5([data])","uhashlib.sha1([data])","uhashlib.sha224([data])","uhashlib.sha256([data])","uhashlib.sha384([data])","uhashlib.sha512([data])","uid","uid.","uid:","uid]","uid_len))","uint16","uint16,","uint16.","ujson","ujson.dumps(obj)","ujson.load(fp)","ujson.loads(str)","ulp","ultra","umodbu","unabl","unaccept","unaffected.","unavail","unavailable.","unb","unbound","uncondition","unconditionally,","undefin","undefined.","under","underli","underlyingly,","underscor","understand","understanding.","unexpect","unfeas","unfortun","unfortunately,","unhandl","uninstal","uniqu","unique,","unit","unit).","unit.","univers","unix","unless","unlik","unlock","unlocked.","unmount","unpack","unplug","unregist","unsuccessful,","until","unusu","uo","uos.chdir(path)","uos.dupterm(stream_object)","uos.getcwd()","uos.getfree(path)","uos.listdir([dir])","uos.mkdir(path)","uos.mkfs(block_devic","uos.mount(block_device,","uos.remove(path)","uos.rename(old_path,","uos.rmdir(path)","uos.sep:","uos.stat(path)","uos.sync()","uos.uname()","uos.unlink(path)","uos.unmount(path)","uos.urandom(n)","up","up\")","up)","up,","up.","updat","update,","update.","update:","update\\","update_period","update_period=3600)","updated,","updated.","updater.","updater.elf","updater;","updates.","upgrad","upgrade,","upgrade.","upgrades).","upgrading,","uplink","upload","upload,","upload.","uploaded.","uploading.","upon","upper","uptime,","upward","ur","urandom","ure.compile().","ure.compile(regex)","ure.debug","ure.match(regex,","ure.search(regex,","url","url'","url,","url:","us","us)","us,","us.","us915","us915.","us:","usa,","usability,","usabl","usag","usage,","usage:","usb","usb\"","usb)","usb.","use,","use.","use:","used,","used.","used/import","used;","useful,","user","user,","user.","userdata,","userid","usermod","usernam","username,","username:","users,","users.","using.","using:","usocket","ussl","ustruct","ustruct.calcsize(fmt)","ustruct.pack(fmt,","ustruct.pack_into(fmt,","ustruct.unpack(fmt,","ustruct.unpack_from(fmt,","usual","usual...","utc","utc.","utc:',","util","util.","util/tickets/","util:","utilis","utility:","utim","utime.gmtime([secs])","utime.localtime(),","utime.localtime([secs])","utime.mktime()","utime.sleep(seconds)","utime.sleep_ms(750)","utime.sleep_ms(ms)","utime.sleep_us(us)","utime.ticks_cpu()","utime.ticks_diff(old,","utime.ticks_ms()","utime.ticks_us()","utime.time()","utime.timezone(7200)","utime.timezone([secs])","uucp/dialout","uuid","uuid.","uuids,","v","v,","v0.9","v1,","v1.0","v1.18.1.r1","v1.4.6","v2,","v2.0","v3","v3,","v3.0","v:","v]","val","valid","valid_card","valu","value)","value))","value).","value):","value,","value.","value:","value=1)","value=25)","value=5)","valueerror","values,","values.","values:","vari","variabl","variable).","variable,","variable.","variables,","variables.","variant.","variat","varieti","variou","vdd/2.","vector","vector):","vector.","vehicl","vehicle.","vendor","verbos","verbose.","verbose`","veri","verif","verifi","verizon","verizon,","verizon:","versa.","version","version,","version.","version:","version;","version='v1.8.6","versions.","via","vice","vid:pid=04d8:f013","view","vin","vin,","vin:","virtual","visibl","visible.","visit","visual","visualis","visualisation:","vodafone:","volatil","volden","voltag","voltage)","voltage.","voltmet","vpp)","vpp),","vpp).","vref","vs","vscode","vscode.","w","w.deinit()","w01","w01,","w01:","wait","wait.","waitflag","waiting,","waiting_ack","wake","wake,","wake_","wake_reason_acceleromet","wake_reason_int_pin","wake_reason_push_button","wake_reason_tim","wake_s['wake']","wakeup","wakeup.","wakeup...","walk","want","warn","warning,","warning:","warranti","watchdog","water","wave","wavelength","way","way,","way.","way:","ways:","ways;","wb).","wdt","wdt(timeout=2000)","wdt.feed()","wdt.init(timeout)","wdt_on_boot_timeout.","we'r","we'v","web","websit","website):","website.","week,","weekday","weekday,","weekli","weight","welcom","welcome(\"alex\")","welcome(name):","welcome_phras","well","well,","well.","welt","weston","whatev","whenev","where:","whether","while(true):","while(waiting_ack):","whilst","white","whole","whose","wi","wide","wide.","widget","widget'","widget.","widgets.","width","wifi","wifi,","wifi.","wifi/bluetooth","wifi/bt","wifi/uart","wifi/wlan.","wifi\\n\")","wifi_pass","wifi_pw,","wifi_ssid","wifi_ssid,","wifiota","wifiota(wifi_ssid,","window","window.","windows,","windows.","windows/linux","windows:","windows;","wipi","wipy,","wipy.","wipy2","wipy2,","wipy2:","wipy3","wipy3,","wipy3:","wipy:","wire","wireless","wirelessly.","wires:","wish","with.","within","without","wizard","wizard,","wl","wl.auth()","wl.connect(net_to_use,","wl.ifconfig()[0])","wl.ifconfig(config=net_properties['wlan_config'])","wl.init(mode=wlan.ap,","wl.isconnected():","wl.mode(wlan.sta)","wl.scan()","wl.ssid()","wlan","wlan',","wlan()","wlan(mode=wlan.sta)","wlan(wlan.sta)","wlan,","wlan.antenna([antenna])","wlan.ap","wlan.ap,","wlan.ap.","wlan.auth([auth])","wlan.channel([channel])","wlan.connect(\"yourwifinetwork\",","wlan.connect('mywifi',","wlan.connect('your","wlan.connect(net.ssid,","wlan.connect(ssid,","wlan.connect(ssid='mynetwork',","wlan.connect(ssid='mywifi',","wlan.deinit()","wlan.disconnect()","wlan.ext_","wlan.ext_ant.","wlan.ifconfig(config=('192.168.0.107',","wlan.ifconfig(config=('192.168.0.4',","wlan.ifconfig(config=('192.168.178.107',","wlan.ifconfig(id=0,","wlan.init(mode,","wlan.init(mode=wlan.ap,","wlan.init(mode=wlan.sta)","wlan.int_ant,","wlan.isconnected()","wlan.isconnected():","wlan.mac()","wlan.mode()","wlan.mode([mode])","wlan.scan()","wlan.ssid([ssid])","wlan.sta,","wlan.sta_ap","wlan.sta_ap.","wlan.wep","wlan.wep,","wlan.wpa,","wlan.wpa2","wlan.wpa2,","wlan.wpa2.","wlan.wpa2_","wlan.wpa2_ent.","wlan_config","wlist,","wmac","wob","woken","won't","won't","word","word.","words,","work","work.","workaround","working,","working.","world\"","world.","wpa2","wrap","wrapper","write","write()","write.","write=0x00)","write_buf","write_bytes(self,","write_flash","writing,","written","written,","written.","wrong","wrong,","wrong.","ws2812b","wupa","www.pycom.io","www.pycom.io.","x","x)","x,","x.","x.x.x","x/y.","x/y/z","x]","xlist[,","xml","xxx","xxxx","xxxx,","y","y)","y.","y/x.","yaw","yaw.","year","yearday","yearday)","yellow","yet,","you'll","you'r","you'v","you.","you?","yourself","you'll","you'r","you'v","yum","z","z,","z.","zadig","zealand,","zealand.","zero","zero)","zero,","zero.","zip","zip()","zone","zones:","zsp0","zsp1","{","{\"b\":","{'alex':'2604","{'pwd':","{list,chip_id,wmac,smac,sigfox,exit,flash,copy,write,write_remote,wifi,pybytes,cb,nvs,ota,lpwan,erase_fs,erase_all}","{}","{}\".format(chr.value()))","{}\".format(coord,","{}\".format(ubinascii.hexlify(adv.mac)))","{}'.format(char.uuid(),","{}'.format(service.uuid()))","{}\\n\".format(coord,","|","|=","}","})","},","~/.atom/.apm/pymkr","~/.atom/.apmrc","~/.atom/packages/pymakr","~/.config/atom/cach","~/.screenrc","​","​aw","​integr","–","—","—version","‘fail","‘firmwar","‘hello')","‘past","‘serialport'","“a","“availability:”","“gener","“python=/usr/bin/python2.7”","“p”","“software”),","“x\"","→","✔"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Introduction\nWelcome to the Pycom documentation site. We recommend reading through all the sections to familiarise yourself with the various tools and features available to you to help you develop on your Pycom module.\nTo get started, read through the Getting Started Guide then feel free to jump straight into the tutorials and examples in Tutorials & Examples to begin building your projects.\n\nProducts\nGetting Started\nPymakr\nTutorials\nAPI Documentation\nProduct Info\nPybytes\n\n"},"products.html":{"url":"products.html","title":"Pycom Products","keywords":"","body":"Pycom Products\nPycom Products\nBelow you will find tables of all Pycom products. These tables illustrate the functionality of our various products, their compatibility with each other, as well as what accessories are required to utilise certain functionality.\nDevelopment Boards\n\n\n\nModule\nWiFi\nBluetooth\nLoRa\nSigfox\nLTE CAT-M1NB-IoT\n\n\n\n\nWiPy 3.0\n✔\n✔\n\n\n\n\n\nSiPy\n✔\n✔\n\n✔\n\n\n\nGPy\n✔\n✔\n\n\n✔\n\n\nLoPy\n✔\n✔\n✔\n\n\n\n\nLoPy4\n✔\n✔\n✔\n✔\n\n\n\nFiPy\n✔\n✔\n✔\n✔\n✔\n\n\nAntennas\nExternal WiFi/BT Antenna Kit\nExternal WiFi/BT Antenna Kit\nLoRa & Sigfox Antenna Kit\nLoRa & Sigfox Antenna Kit\nLTE-M Antenna Kit\n\n\n\nAccessories\n\n \n \n Accessory\n Expansion Board\n \n Pysense\n \n Pytrack\n \n Pyscan\n \n \n \n \n \n PyCase\n \n ✔\n \n \n \n \n \n IP67 Case for Expansion Board\n \n ✔\n \n \n \n \n \n IP67 Case for Pysense/Pytrack/Pyscan\n \n \n ✔\n ✔\n ✔\n \n \n IP67 Case (universal)\n \n ✔\n ✔\n ✔\n ✔\n \n \n LiPo Battery (user-supplied)\n ✔\n ✔\n ✔\n ✔\n \n \n Micro USB Cable Required (user-supplied)\n ✔\n ✔\n ✔\n ✔\n \n \n## OEM Modules\n\n\n\nOEM Module\nL01/W01 Reference Board\nUniversal Reference Board\n\n\n\n\nW01\n✔\n✔\n\n\nL01\n✔\n✔\n\n\nL04\n\n✔\n\n\nG01\n\n✔\n\n\n\n"},"gettingstarted/introduction.html":{"url":"gettingstarted/introduction.html","title":"Introduction","keywords":"","body":"Introduction\nSo, you've decided to order a Pycom development module. Firstly we would like to congratulate you in making an excellent decision. If you haven't yet placed your order we highly recommend you check out the products page before you place your order to ensure you know which accessories you might require.\n\nStep 1: Setting up the hardware\nIn the first part of this getting started guide, we will take you through setting up your device. Firstly we will cover how to connect the module to your computer either via USB or WiFi. Secondly we will explain how to connect various accessories such as antennas or SIM cards to your module.\nStep 2: Setting up your computer\nNow that your module is successfully connected, you will need to install some software on your computer to interface with it. The second part of this guide will guide you through installing drivers; performing firmware updates for your module/accessories to ensure you have the most stable and feature packed version; and how to setup the software use to program the device.\nStep 3: Using your module\nNow that you have a connected module and all the required software installed it is time to begin programming your device. This part of the guide will get you started with a basic example and point you in the right direction for getting your device connected to your chosen network.\nStep 4: Connecting to a network\nNow that you familiar with programming your device you will no doubt be keen to get it connected to one of the advertised wireless networks. This usually requires some registration. This step will detail how to get registered and connected to various wireless networks.\nYou can navigate through this guide using the arrow buttons at the bottom of the page.\n\n"},"gettingstarted/connection/":{"url":"gettingstarted/connection/","title":"Hardware Setup","keywords":"","body":"Hardware Setup\nThis chapter of the documentation will show you how to connect you Pycom module. For each device there are detailed instructions on how to connect your module to one of our base boards, a USB UART adapter or WiFi as well as what antennas you might need to connect. Please select your module below to be taken to the appropriate guide.\n"},"gettingstarted/connection/lopy.html":{"url":"gettingstarted/connection/lopy.html","title":"LoPy","keywords":"","body":"LoPy\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWiFiLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the LoPy module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the LoPy module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the LoPy module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\nFirstly you will need to connect power to your LoPy. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the LoPy via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the LoPy:\n\nBy default, when the LoPy boots, it will create a WiFi access point with the following credentials:\nSSID: lopy-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the LoPy. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nLora\nIf you intend on using the LoRa connectivity of the LoPy you must connect a LoRa antenna to your LoPy before trying to use LoRa otherwise you risk damaging the device.\n\nThe LoPy only supports LoRa on the 868MHz or 915MHz bands. It does not support 433MHz. For this you will require a LoPy4.\n\n\nFirstly you will need to connect the U.FL to SMA pig tail to the LoPy using the U.FL connector on the same side of the LoPy as the LED.\n\n\n\nIf you are using a pycase, you will next need to put the SMA connector through the antenna hole, ensuring you align the flat edge correctly, and screw down the connector using the provided nut.\nFinally you will need to screw on the antenna to the SMA connector.\n\n\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the LoPy, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the LoPy in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\nDeep Sleep current issue\nThe LoPy, SiPy, and WiPy 2.0 experience an issue where the modules maintain a high current consumption in deep sleep mode. This issue has been resolved in all newer products. The cause for this issue is the DC to DC switch mode converter remains in a high performance mode even when the device is in deep sleep. The flash memory chip also does not power down. A more detailed explanation can be found here.\n"},"gettingstarted/connection/lopy4.html":{"url":"gettingstarted/connection/lopy4.html","title":"LoPy 4","keywords":"","body":"LoPy 4\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWifiLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the LoPy4 module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the LoPy4 module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the LoPy4 module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\n Firstly you will need to connect power to your LoPy4. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the LoPy4 via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the LoPy4:\n\nBy default, when the LoPy4 boots, it will create a WiFi access point with the following credentials:\nSSID: lopy4-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the LoPy4. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nLora/Sigfox\nIf you intend on using the LoRa/Sigfox connectivity of the LoPy4 you must connect a LoRa/Sigfox antenna to your LoPy4 before trying to use LoRa/Sigfox otherwise you risk damaging the device.\n\n\nFirstly you will need to connect the U.FL to SMA pig tail to the LoPy4 using one of the two the U.FL connectors on the same side of the LoPy4 as the LED. The one on the left hand side is for 433MHz (LoRa only), the one of the right hand side is for 868MHz/915MHz (LoRa & Sigfox). Note: This is different from the LoPy.\n\n\n\nIf you are using a pycase, you will next need to put the SMA connector through the antenna hole, ensuring you align the flat edge correctly, and screw down the connector using the provided nut.\nFinally you will need to screw on the antenna to the SMA connector.\n\n\nSince the LoRa chip only runs on one frequency band at a time you only need to connect an antenna to the appropriate U.FL connecor. You should be supplied with a the antenna that suits the band you intend using.\n\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the LoPy4, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the LoPy4 in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\n"},"gettingstarted/connection/sipy.html":{"url":"gettingstarted/connection/sipy.html","title":"SiPy","keywords":"","body":"SiPy\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWiFiLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the SiPy module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the SiPy module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the SiPy module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\nFirstly you will need to connect power to your SiPy. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the SiPy via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the SiPy:\n\nBy default, when the SiPy boots, it will create a WiFi access point with the following credentials:\nSSID: sipy-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the SiPy. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nSigfox\nIf you intend on using the Sigfox connectivity of the SiPy you must connect a Sigfox antenna to your SiPy before trying to use Sigfox otherwise you risk damaging the device.\n\n\nFirstly you will need to connect the U.FL to SMA pig tail to the SiPy using the U.FL connector on the same side of the SiPy as the LED.\n\n\n\nIf you are using a pycase, you will next need to put the SMA connector through the antenna hole, ensuring you align the flat edge correctly, and screw down the connector using the provided nut.\nFinally you will need to screw on the antenna to the SMA connector.\n\n\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the FiPy, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the FiPy in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\nDeep Sleep current issue\nThe LoPy, SiPy, and WiPy 2.0 experience an issue where the modules maintain a high current consumption in deep sleep mode. This issue has been resolved in all newer products. The cause for this issue is the DC to DC switch mode converter remains in a high performance mode even when the device is in deep sleep. The flash memory chip also does not power down. A more detailed explanation can be found here.\n"},"gettingstarted/connection/gpy.html":{"url":"gettingstarted/connection/gpy.html","title":"GPy","keywords":"","body":"GPy\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWiFiLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the GPy module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the GPy module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the GPy module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\nFirstly you will need to connect power to your GPy. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the GPy via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the GPy:\n\nBy default, when the GPy boots, it will create a WiFi access point with the following credentials:\nSSID:gpy-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the GPy. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nLTE Cat-M1/NB-IoT\nIf you intend on using the LTE CAT-M1 or NB-IoT connectivity of the GPy you must connect a LTE CAT-M1/NB-IoT antenna to your GPy before trying to use LTE Cat-M1 or NB-IoT otherwise you risk damaging the device.\n\n\nYou will need to connect the antenna to the GPy using the U.FL connector on the same side of the GPy as the LED.\n\n\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the GPy, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the GPy in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\nSIM card \nIf you intend on using the LTE CAT-M1 or NB-IoT connectivity of the GPy you will need to insert a SIM card into your GPy. It should be noted that the GPy does not support regular LTE connectivity and you may require a special SIM. It is best to contact your local cellular providers for more information on acquiring a LTE CAT-M1/NB-IoT enabled nano SIM.\n\n"},"gettingstarted/connection/fipy.html":{"url":"gettingstarted/connection/fipy.html","title":"FiPy","keywords":"","body":"FiPy\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWiFiWhen using the expansion board with a FiPy, you will need to remove the CTS and RTS jumpers as these interfere with communication with the cellular modem.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the FiPy module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nWhen using the expansion board with a FiPy, you will need to remove the CTS and RTS jumpers as these interfere with communication with the cellular modem.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the FiPy module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the FiPy module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\nFirstly you will need to connect power to your FiPy. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the FiPy via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the FiPy:\n\nBy default, when the FiPy boots, it will create a WiFi access point with the following credentials:\nSSID: fipy-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the FiPy. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nLora/Sigfox\nIf you intend on using the LoRa/Sigfox connectivity of the FiPy you must connect a LoRa/Sigfox antenna to your FiPy before trying to use LoRa/Sigfox otherwise you risk damaging the device.\n\nThe FiPy only supports LoRa on the 868MHz or 915MHz bands. It does not support 433MHz. For this you will require a LoPy4.\n\n\nFirstly you will need to connect the U.FL to SMA pig tail to the FiPy using the U.FL connector on the same side of the FiPy as the LED.\n\n\n\nIf you are using a pycase, you will next need to put the SMA connector through the antenna hole, ensuring you align the flat edge correctly, and screw down the connector using the provided nut.\nFinally you will need to screw on the antenna to the SMA connector.\n\n\nLTE Cat-M1/NB-IoT\nIf you intend on using the LTE CAT-M1 or NB-IoT connectivity of the FiPy you must connect a LTE CAT-M1/NB-IoT antenna to your FiPy before trying to use LTE Cat-M1 or NB-IoT otherwise you risk damaging the device.\n\n\nYou will need to connect the antenna to the FiPy using the U.FL connector on the under side of the FiPy.\n\n\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the FiPy, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the FiPy in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\nSIM card \nIf you intend on using the LTE CAT-M1 or NB-IoT connectivity of the FiPy you will need to insert a SIM card into your FiPy. It should be noted that the FiPy does not support regular LTE connectivity and you may require a special SIM. It is best to contact your local cellular providers for more information on acquiring a LTE CAT-M1/NB-IoT enabled nano SIM.\n\n"},"gettingstarted/connection/wipy.html":{"url":"gettingstarted/connection/wipy.html","title":"WiPy","keywords":"","body":"WiPy\nBasic connection\nExp Board 2.0Exp Board 3.0Pytrack/Pysense/PyscanUSB UART AdapterWiFiLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the WiPy module on the the expansion board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to an Expansion Board 3.0, you should update the firmware on the Expansion Board 3.0. Instructions on how to do this can be found here.\n\nLook for the reset button on the module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the expansion board.\n\nInsert the WiPy module on the Expansion Board with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible.\n\nBefore connecting your module to a Pysense/Pytrack/Pyscan board, you should update the firmware on the Pysense/Pytrack/Pyscan. Instructions on how to do this can be found here.\n\nLook for the reset button on the WiPy module (located at a corner of the board, next to the LED).\n\nLocate the USB connector on the Pysense/Pytrack/Pyscan.\n\nInsert the module on the Pysense/Pytrack/Pyscan with the reset button pointing towards the USB connector. It should firmly click into place and the pins should now no longer be visible. \n\nFirstly you will need to connect power to your WiPy. You will need to supply 3.5v-5.5v to the Vin pin.\n\nNote: This method of connection is not recommended for first time users. It is possible to lock yourself out of the device, requiring a USB connection.In order to access the WiPy via WiFi you only need to provide 3.5v - 5.5v on the Vin pin of the WiPy:\n\nBy default, when the WiPy boots, it will create a WiFi access point with the following credentials:\nSSID: wipy-wlan\n\npassword: www.pycom.io\n\n\nOnce connected to this network you will be able to access the telnet and FTP servers running on the WiPy. For both of these the login details are:\nusername: micro\n\npassword: python\n\n\n\nAntennas\nWiFi/Bluetooth (optional)\nAll Pycom modules, including the WiPy, come with a on-board WiFi antenna as well as a U.FL connector for an external antenna. The external antenna is optional and only required if you need better performance or are mounting the WiPy in such a way that the WiFi signal is blocked. Switching between the antennas is done via software, instructions for this can be found here.\n\nDeep Sleep current issue\nThe LoPy, SiPy, and WiPy 2.0 experience an issue where the modules maintain a high current consumption in deep sleep mode. This issue has been resolved in all newer products. The cause for this issue is the DC to DC switch mode converter remains in a high performance mode even when the device is in deep sleep. The flash memory chip also does not power down. A more detailed explanation can be found here.\nWiPy 2.0 vs WiPy 3.0\nThe WiPy 3.0 is an upgraded version of the WiPy 2.0 with the following changes:\n\nThe FLASH has been upgraded from 4MB to 8MB.\nThe RAM has been upgraded from 512KB to 4MB.\nThe deepsleep current consumption issue has been fixed\nThe antenna select pin has moved to GPIO21 (P12)\n\n"},"gettingstarted/installation/":{"url":"gettingstarted/installation/","title":"Software","keywords":"","body":"Software\nTo get you up and running, Pycom provides a suite of tools to assist with developing and programming your Pycom Devices:\n\nDrivers: If you are using Microsoft Windows, you might be required to install drivers for our products to function correctly.\nPycom firmware update utility: This tool automates the process of upgrading the firmware of your Pycom device. It is important that you use this tool before you attempt to use your device. Not only to ensure you have the most stable and feature packed firmware, but also to ensure all the functionality of your device is enable. E.g. this tool also activates your two year free sigfox connectivity.\nDevelopment Environment: Pymakr is a plug-in for Atom and Visual Studio Code developed by Pycom to make development for Pycom modules super easy. It allows you to use your favourite text editor while simplifying the process of uploading code to the device.\n\n"},"gettingstarted/installation/drivers.html":{"url":"gettingstarted/installation/drivers.html","title":"Drivers","keywords":"","body":"Drivers\nLinux\nYou should not need to install any drivers for our devices to be recognised by Linux. You may how ever need to adjust permissions to make sure you have access to the serial port. On most distributions this can be done by adding your user to the dialout user group. Please check the specific instructions for your linux distribution for how to do this.\nmacOS\nOn macOS you shouldn't need to do anything special to get our device to work.\nWindows\nAll our products will work out of the box for Windows 8/10/+. If using Windows 7, drivers to support the Pysense/Pytrack/Pyscan/Expansion Board 3.0 boards will need to be installed.\nDownload\nPlease download the driver software from the link below.\nPysense/Pytrack/Pyscan/Expansion Board 3.0 Serial Driver (save the file to your computer)\nInstallation\nFirst navigate open the Windows start menu and search/navigate to `Device Manager. You should see your Pytrack/Pysense in the dropdown under other devices.\n\nRight click the device and select Update Driver Software.\n\nSelect the option to Browse my computer for driver software.\n\nNext you will need to navigate to where you downloaded the driver to (e.g. Downloads Folder).\n\nSpecify the folder in which the drivers are contained. If you haven't extracted the .zip file, please do this before selecting the folder.\n\nYou may receive a warning, suggesting that Windows can't verify the publisher of this driver. Click Install this driver software anyway as this link points to our official driver.\n\nIf the installation was successful, you should now see a window specifying that the driver was correctly installed.\n\nTo confirm that the installation was correct, navigate back to the Device Manager and click the dropdown for other devices. The warning label should now be gone and Pytrack/Pysense should be installed.\n\n"},"gettingstarted/installation/firmwaretool.html":{"url":"gettingstarted/installation/firmwaretool.html","title":"Updating Firmware","keywords":"","body":"Updating Firmware\nWe strongly recommend you to upgrade your firmware to the latest version as we are constantly making improvements and adding new features to the devices.\nHere are the download links to the update tool. Please download the appropriate one for your OS and follow the instructions on the screen.\n\nWindows\nmacOS (10.11 or Higher)\nLinux (requires dialog and python-serial package)\n\nPrevious versions of firmware are available for download here.\n\nUpdating Device Firmware\nThe basic firmware upgrade procedure can be found below, please follow these steps carefully:\nAfter you're done with upgrading, you can use the Pymakr Plugins to upload and run programs in your device.\nExp Board 2.0Exp Board 3.0Disconnect your device from your computer\n\nInsert module into the Expansion Board\n\nConnect a jumper cable or wire between G23 and GND\n\nReconnect the board via USB to your computer, this puts the device in ‘firmware update mode'.\n\nRun the Firmware Upgrade tool\n\nRemove the G23 to GND jumper cable/wire\nReboot the device (button or power off then on), your device is now ready to use\nIf you are having any issues, make sure the TX and RX jumpers are present on your Expansion Board, as the jumpers sometimes come loose in the box during transport. Without these jumpers, the updater will fail.\nAfter you're done with upgrading, you can use the Pymakr Plugins to upload and run programs in your device.\n"},"gettingstarted/installation/pymakr.html":{"url":"gettingstarted/installation/pymakr.html","title":"Pymakr","keywords":"","body":"Pymakr\n\nPymakr Plugins \nTo make it as easy as possible Pycom has developed a plugin for two popular text editors, called Pymakr. These plugins have been built and are available for the following platforms:\n"},"gettingstarted/programming/":{"url":"gettingstarted/programming/","title":"Programming the modules","keywords":"","body":"Programming the modules\nNow that you have connected and updated your pycom module and installed all the required software on your computer, we can begin programming your Pycom module.\nIf this is your first time using a Pycom module we highly recommend you read through the following pages:\n\nIntroduction to MicroPython: This page will explain what Micropython is and its relation to Python.\nMicroPython Examples: We also recommend you browse these short MicroPython examples to familiarise yourself with its syntax. This is not meant as a comprehensive guide to MicroPython programming but rather a reference to those who already know programming. If you are new to python, or programming all together, we highly recommend searching the internet for Python tutorials. There are many very good tutorials available for free and the skills you learn will be easily transferable to our platform.\nYour first Pymakr project: Once you understand what MicroPython is, this guide will take you through setting up your first Pymakr project to blink the on-board RGB LED. This guide will explain the structure of a MicroPython project as well as how to upload it to your module.\n\nOnce you are familiar with MicroPython and Pymakr, the recommended way of uploading code to your module, you can explore the pages below. These will discuss in greater detail the various mechanisms for running code on your device as well as how to recover it if something goes wrong.\n\nREPL: The REPL (Read Evaluate Print Loop) is an interactive terminal that allows you to type in and test your code directly on the device, just like interactive python interpreter. It can be accessed via UART or Telnet. This is accessed easiest by using Pymakr but if you wish to use other tools, this page will explain how.\nFTP: All Pycom modules start up with a WiFi access point enabled, and a simple FTP server running on it. Once connected to the WiFi network, you can use FTP to transfer files over to your device wirelessly. This can be very useful if you do not have physical access to your device.\nSafe Boot: It is possible that some code you upload to your module will prevent you accessing the REPL or FTP server, preventing you from updating your scripts. This guide will detail how to safe boot your module and how to remove the offending scripts from it.\n\n"},"gettingstarted/programming/micropython.html":{"url":"gettingstarted/programming/micropython.html","title":"Introduction to MicroPython","keywords":"","body":"Introduction to MicroPython\nOur boards work with MicroPython; a Python 3.5 implementation that is optimised to run on micro controllers. This allows for much faster and more simple development process than using C.\n\nBooting into MicroPython\nWhen booting, two files are executed automatically: first boot.py and then main.py. These are placed in the /flash folder on the board. Any other files or libraries can be placed here as well, and can be included or used from boot.py or main.py.\nThe folder structure in /flash looks like the picture below. The files can be managed either using FTP or using the Pymakr Plugin.\n\nTips & Tricks\nMicropython shares majority of the same syntax as Python 3.5. The intention of this design is to provide compatibility upwards from Micropython to Python 3.5, meaning that code written for Micropython should work in a similar manner in Python 3.5. There are some minor variations and these should taken viewed as implementation differences.\nMicropython also has a number of Micropython specific libraries for accessing hardware level features. Specifics relating to those libraries can be found in the Firmware API Reference section of this documentation.\nMicropython, unlike C/C++ or Arduino, does not use braces {} to indicate blocks of code specified for class and function definitions or flow control. Blocks of code are denoted by line indentation, which is strictly enforced.\nThe number of spaces in the indentation is variable but all statements within a block must be indented the same amount.\n\n"},"gettingstarted/programming/examples.html":{"url":"gettingstarted/programming/examples.html","title":"MicroPython Examples","keywords":"","body":"MicroPython Examples\nTo get you started with Python (MicroPython) syntax, we've provided you with a number of code examples.\nVariable Assignment\nAs with Python 3.5, variables can be assigned to and referenced. Below is an example of setting a variable equal to a string and then printing it to the console.\nvariable = \"Hello World\"\nprint(variable)\n\nConditional Statements\nConditional statements allow control over which elements of code run depending on specific cases. The example below shows how a temperature sensor might be implemented in code.\ntemperature = 15\ntarget = 10\nif temperature > target:\n print(\"Too High!\")\nelif temperature \nLoops (For & While loop)\nLoops are another important feature of any programming language. This allows you to cycle your code and repeat functions/assignments/etc.\nfor loops allow you to control how many times a block of code runs for within a range.\nx = 0\nfor y in range(0, 9):\n x += 1\nprint(x)\n\nwhile loops are similar to for loops, however they allow you to run a loop until a specific conditional is true/false. In this case, the loop checks if x is less than 9 each time the loop passes.\nx = 0\nwhile x \nFunctions\nFunctions are blocks of code that are referred to by name. Data can be passed into it to be operated on (i.e. the parameters) and can optionally return data (the return value). All data that is passed to a function is explicitly passed.\nThe function below takes two numbers and adds them together, outputting the result.\ndef add(number1, number2):\n return number1 + number2\n\nadd(1, 2) # expect a result of 3\n\nThe next function takes an input name and returns a string containing a welcome phrase.\ndef welcome(name):\n welcome_phrase = \"Hello, \" + name + \"!\"\n print(welcome_phrase)\n\nwelcome(\"Alex\") # expect \"Hello, Alex!\"\n\nData Structures\nPython has a number of different data structures for storing and manipulating variables. The main difference (regarding data structures) between C and Python is that Python manages memory for you. This means there's no need to declare the sizes of lists, dictionaries, strings, etc.\nLists\nA data structure that holds an ordered collection (sequence) of items.\nnetworks = ['lora', 'sigfox', 'wifi', 'bluetooth', 'lte-m']\nprint(networks[2]) # expect 'wifi'\n\nDictionaries\nA dictionary is like an address-book where you can find the address or contact details of a person by knowing only his/her name, i.e. keys (names) are associate with values (details).\naddress_book = {'Alex':'2604 Crosswind Drive','Joe':'1301 Hillview Drive','Chris':'3236 Goldleaf Lane'}\nprint(address_book['Alex']) # expect '2604 Crosswind Drive'\n\nTuple\nSimilar to lists but are immutable, i.e. you cannot modify tuples after instantiation.\npycom_devices = ('wipy', 'lopy', 'sipy', 'gpy', 'fipy')\nprint(pycom_devices[0]) # expect 'wipy'\n\nFor more Python examples, check out these tutorials. Be aware of the implementation differences between MicroPython and Python 3.5.\n\n"},"gettingstarted/programming/first-project.html":{"url":"gettingstarted/programming/first-project.html","title":"Your first Pymakr project","keywords":"","body":"Your first Pymakr project\nThis guide will take you through how to setup your first project with Pymakr and make the on-board RGB LED flash various colours.\nCreating a project in Pymakr\n\nFirstly you will need to create a new, empty, directory on your computer.\nFor this example we will create one called RGB-Blink.\n\nNext you will need to open either Atom or Visual Studio Code depending on\nwhich you setup previously.\n\nOnce the text editor has loaded you will need to click File > Open, and open the directory you created in step 1\n\n\nIf you are using Atom, it is important to check at this point that Atom has successfully identified the project. The name of the directory you created in step 1 (RGB-Blink in this case) should be shown in the Pymakr pane like so:\n\nIf this is not the case you can press alt-ctrl-r on Windows/Linux or ctrl-alt-cmd-l on macOS, in order to reload Atom and fix the issue.\n\n\nNow that you have a project created, we need to add some files to it. A standard MicroPython project has the following structure:\n\nRGB-Blink\n|-lib\n| |- some_library.py\n|-boot.py\n|-main.py\n\n\nboot.py This is the first script that runs on your module when it\nturns on. This is often used to connect a module a a WiFi network so that\nTelnet and FTP can be used without connecting to the WiFi AP created by the\nmodule and not cluttering up the main.py file. As a beginner you do not\nneed to use a boot.py.\n\nmain.py This script runs directly after boot.py and should contain\nthe main code you wish to run on your device.\n\nlib It is often a good idea to split out re-usable code into libraries.\nIf you want to create or use libraries created by others, you will need to\ncreate a lib directory and put the library files in this. It is important\nthat you put .py files directly into lib rather than creating a directory\ntree. By default MicroPython will not detect any libraries within\nsub-directories.\n\n\nFor this example, you will just need to create a main.py file.\nNow that the project structure is setup, you may wish to configure project specific settings for Pymakr e.g. Which serial port to use. On Atom you need to click the ^ button on the Pymakr pane, then click Project Settings. On Visual Studio Code you need to click the All commands button on the bottom of the windows, then click Pymakr > Project Settings. This creates a file called pymakr.conf inside your project and populates it with default settings copied over from your global settings. A detailed explanation of these settings can be found here.\nControlling the on-board LED\nNow that you have setup and configured your project, we can move on to programming your module. The first thing we will need to do is import some libraries in order to interact with the on-board LED. The Pycom firmware comes with a large amount of libraries for standard functionality built-in. You can find out more about these in the API documentation. For this example you will need to open the main.py file and add the following code:\nimport pycom\nimport time\n\nThis will import two libraries, Pycom which is responsible for Pycom specific features, such as the on-board LED and time which is a standard library used timing and delays.\nYou may have noticed that when you power up your Pycom module, the on-board LED blinks blue on a regular basis. This \"heartbeat\" is used as a way of know that your module has powered up and started correctly. Before we can change the colour of this LED we need to disable this heart beat. Below your imports you will need to add the following:\npycom.heartbeat(False)\n\nNow it's time to test your code. On the Pymakr pane/bottom of the window you will see a run button. (If you haven't connected to your device yet, you will need to do that first). When you click the run button, the code in the currently open file will be executed on the device, but it won't copy it to the device. After running this code, you should see that that on-board LED stops blinking blue.\nNow that we can confirm the device is connected and Pymakr is able to run code on it, we can complete our script to blink the LED like so:\nimport pycom\nimport time\n\npycom.heartbeat(False)\n\nwhile True:\n pycom.rgbled(0xFF0000) # Red\n time.sleep(1)\n pycom.rgbled(0x00FF00) # Green\n time.sleep(1)\n pycom.rgbled(0x0000FF) # Blue\n time.sleep(1)\n\nOnce you run the above script, it will run forever. You will notice this prevents you from accessing the interactive REPL on the device (You cannot see the >>> prompt). In order to stop the script, click onto the Pymakr terminal, and press ctrl-c on your keyboard. This should stop the script running and return you to the interactive REPL.\nUploading to your module\nIn the previous section we got code running on on your Pycom module using the run feature of Pymakr. This is useful for quick testing but has a couple of drawbacks. Firstly the code does not remain on the device permanently. If you reboot the device, it will no longer be running your code. Secondly, it will only work if you are using libraries built into the firmware. If you need any extra libraries, these need to be copied to the device first. This is where the upload feature comes in. If instead of run you click upload, Pymakr will upload all the files in the project (so long as their type is in the sync_file_types setting for your project). These then persist on your device even between reboots, and allows you to use libraries from the lib folder in your project.\nIf you need to remove files from your device you have two options, either connect via FTP and manage your files that way or format the device's internal flash like so:\nimport os\nos.mkfs('/flash')\n\n"},"gettingstarted/programming/repl/":{"url":"gettingstarted/programming/repl/","title":"REPL","keywords":"","body":"REPL\nREPL stands for Read Evaluate Print Loop, and is the name given to the interactive MicroPython prompt that is accessible on the Pycom devices. Using the REPL is by far the easiest way to test out Python code and run commands. You can use the REPL in addition to writing scripts in main.py.\nThe following pages will explain how to use the REPL with both Serial USB and Telnet connections.\nThe REPL includes the following features:\n\nInput history: use arrow up and arrow down to scroll through the history\nTab completion: press tab to auto-complete variables or module names\nHalt any executing code: with Ctrl-C\nCopy/paste code or output: Ctrl-C and Ctrl-V\n\nThere are a number of useful shortcuts for interacting with the MicroPython REPL. See below for the key combinations;\n\nCtrl-A on a blank line will enter raw REPL mode. This is similar to permanent paste mode, except that characters are not echoed back.\nCtrl-B on a blank like goes to normal REPL mode.\nCtrl-C cancels any input, or interrupts the currently running code.\nCtrl-D on a blank line will do a soft reset.\nCtrl-E enters ‘paste mode' that allows you to copy and paste chunks of text. Exit this mode using Ctrl-D.\nCtrl-F performs a \"safe-boot\" of the device that prevents boot.py and main.py from executing\n\n\n"},"gettingstarted/programming/repl/serial.html":{"url":"gettingstarted/programming/repl/serial.html","title":"Serial USB (UART)","keywords":"","body":"Serial USB (UART)\nTo use the REPL, a Pycom device must be connected to the host computer with a USB connection either to an Expansion Board or to serial converter (a diagram of how to do this can be found the the getting started page for your module).\nIn order to connect to the REPL over USB serial, there are multiple methods. Detailed below are the explanations of how to do it in MacOS, Linux and Windows.\nAll platforms\nBy far the easiest way to access the USB UART REPL is via the our Pymakr plug-in for Atom and Visual Studio Code. This adds a pane to the bottom of the editors that allows you to directly access the REPL and any output from the device. Detailed instructions on how to setup Pymakr can be found here.\nmacOS and Linux\nTo open a serial USB connection from macOS, any serial tool may be used; in this example, the terminal tool screen will be used.\nOpen a terminal instance and run the following commands:\n$ screen /dev/tty.usbmodem* 115200\n\nUpon exiting screen, press CTRL-A CTRL-\\. If the keyboard does not support the \\-key (i.e. an obscure combination for \\ like ALT-SHIFT-7 is required), the key combination can be remapped for the quit command:\n\ncreate ~/.screenrc\nadd bind q to the exit command\n\nThis will allow screen to exited by pressing CTRL-A Q.\nOn Linux, picocom or minicom may be used instead of screen. The usb serial address might also be listed as /dev/ttyUSB01 or a higher increment for ttyUSB. Additionally, the elevated permissions to access the device (e.g. group uucp/dialout or use sudo) may be required.\n\nWindows\nA terminal emulator is needed to open the connection from Windows; the easiest option is to download the free program, PuTTY.\nCOM Port\nTo use PuTTY the serial port (COM port) in which the Pycom device is connected, must be located. In Windows, this information can be found from the 'Device Manager' program.\n\nOpen the Windows start menu and search for 'Device Manager'\nThe COM port for the Pycom device will be listed as 'USB Serial Device' or a similar name\nCopy/Write down the associated COM port (e.g. COM4)\n\nUsing Putty\n\nWith PuTTY open, click on Session in the left-hand panel\nNext click the Serial radio button on the right and enter the associated\nCOM port (e.g. COM4) in the Serial Line box\n\nFinally, click the Open button\n\n\n\n"},"gettingstarted/programming/repl/telnet.html":{"url":"gettingstarted/programming/repl/telnet.html","title":"Telnet REPL","keywords":"","body":"Telnet REPL\nPycom devices also support a connection via telnet, using the device's on board WiFi/WLAN. Connect to the device's WiFi Access Point (AP) and using the following credentials to connect to the AP. The WiFi SSID will appear upon powering on a Pycom Device for the first time (e.g. lopy-). To re-enable this feature at a later date, please see network.WLAN.\n\npassword: www.pycom.io\n\nTelnet Server\nAdditionally, to use the MircoPython REPL over telnet, further authentication is required. The default credentials for the telnet server are:\n\nusername: micro\npassword: python\n\nSee network.server for info on how to change the default authentication.\nAll platforms\nBy far the easiest way to access the Telnet REPL is via the our Pymakr plug-in for Atom and Visual Studio Code. This adds a pane to the bottom of the editors that allows you to directly access the REPL and any output from the device. Detailed instructions on how to setup Pymakr can be found here.\nmacOS and Linux\nOnce the host machine is connected to the Pycom device's Access Point, a telnet connection may be opened from a terminal instance.\n$ telnet 192.168.4.1\n\nUpon connection, the telnet program will prompt for the username and password in the section above.\nWindows\nA terminal emulator is needed to open a telnet connection from Windows; the easiest option is to download the free program, PuTTY.\n\nWith PuTTY open, select telnet as connection type and leave the default port (23)\nNext enter the IP address of the Pycom device (e.g. 192.168.4.1)\nFinally click Open\n\nWhen using a Pycom device with a personal, home or office WiFi access point, the telnet connection may still be used. In this instance, the user will need to determine the Pycom device's local IP address and substitute this for 192.168.4.1, referred to in the earlier sections.\n\n"},"gettingstarted/programming/ftp.html":{"url":"gettingstarted/programming/ftp.html","title":"FTP","keywords":"","body":"FTP\nThere is a small internal file system accessible with each Pycom device, called /flash. This is stored within the external serial flash memory. If a microSD card is also connected and mounted, it will be available as well. When the device starts up, it will always boot from the boot.py located in the /flash file system.\nThe file system is accessible via the native FTP server running on each Pycom device. Open an FTP client and connect to:\n\nurl: ftp://192.168.4.1\nusername: micro\npassword: python\n\nSee network.server for information on how to change the defaults. The recommended clients are:\n\nmacOS/Linux: default FTP client\nWindows: Filezilla and FireFTP\n\nFor example, from a macOS/Linux terminal:\n$ ftp 192.168.4.1\n\nThe FTP server doesn't support active mode, only passive mode. Therefore, if using the native unix FTP client, immediately after logging in, run the following command:\nftp> passive\n\nThe FTP server only supports one connection at a time. If using other FTP clients, please check their documentation for how to limit the maximum allowed connections to one at a time.\nFileZilla\nIf using FileZilla, it's important to configure the settings correctly.\nDo not use the quick connect button. Instead, open the site manager and create a new configuration. Within the General tab, ensure that encryption is set to: Only use plain FTP (insecure).\n\nIn the Transfer Settings tab, limit the max number of connections to one. Other FTP clients may behave in a similar ways; visit their documentation for more specific information.\n\n"},"gettingstarted/programming/safeboot.html":{"url":"gettingstarted/programming/safeboot.html","title":"Safe boot","keywords":"","body":"Safe boot\nIf powering up normally or upon pressing the reset button, a Pycom module will boot into standard mode; the boot.py file will be executed first, followed by main.py. It is possible to alter the boot procedure of the module by tying certain pins high or low when the module boots.\nBootloader\nIf you updated your device before using it, you have already put the device into bootloader mode. This is achieved by connecting G23 to GND while the device boots. If you used a Pysense/Pytrack to update, it did this automatically for you. You only need to put your Pycom module into bootloader mode if you are updating its firmware, or are programming your own low level code. This is not required if you are updating your MicroPython code.\nSafe Boot\nSome times the code you have written will prevent you gaining access to the REPL or prevent you updating your code. Some example may be:\n\nYou disabled the WiFi/UART\nYour code gets stuck before reaching the REPL\nYou set a socket as blocking but never receive any data\n\nIn order to fix this you can safe boot your module. This will prevent boot.py and main.py from being executed and will drop you straight into the interactive REPL. After reset, if P12 pin is held high (i.e. connect it to the 3V3 output pin), the heartbeat LED will begin flashing orange slowly. If after 3 seconds the pin is still held high, the LED will start blinking faster. In this mode the module will do the same as previously explained but it will also select the previous OTA image to boot if you have updated the module via the OTA update procedure (updates performed via the firmware update tool do not count). This is useful if you flashed a OTA update that breaks the device.\nPin P12 released during:\n\n\n\n1st 3 secs window\n2nd 3 secs window\n\n\n\n\nDisable boot.py and main.py\nSame as previous but using previous OTA firmware\n\n\n\nThe selection made during safe boot is not persistent, therefore after the next normal reset, the latest firmware will proceed to run again.\nIf problems occur within the filesystem or you wish to factory reset your module to remove your code, run following code in the REPL:\n>>> import os\n>>> os.mkfs('/flash')\n\nBe aware, resetting the flash filesystem will delete all files inside the internal device storage (not the SD card) and they cannot be recovered.\n\nReset\nPycom devices support both soft and hard resets. A soft reset clears the state of the MicroPython virtual machine but leaves hardware peripherals unaffected. To do a soft reset, press Ctrl+D on the REPL or from within a script, run:\n>>> import sys\n>>> sys.exit()\n\nA hard reset is the same as performing a power cycle to the device. In order to hard reset the device, press the reset switch or run:\n>>> import machine\n>>> machine.reset()\n\n"},"gettingstarted/registration/":{"url":"gettingstarted/registration/","title":"Device Registration","keywords":"","body":"Device Registration\nSome of our devices require registration before you can utilise specific features such as certain types of networking. Please see the list below for setup guides to ensure that your device is registered and activated on the various platforms required to access all of the available features.\n\n\n\n\nNot all Pycom devices require activation; most features work immediately out of the box!\n\n"},"gettingstarted/registration/sigfox.html":{"url":"gettingstarted/registration/sigfox.html","title":"Sigfox","keywords":"","body":"Sigfox\nBefore you start, update your device to the latest firmware. Select stable firmware in Firmware updater. After firmware update is done, Sigfox ID and Sigfox PAC were assigned to your device.\nCopy Sigfox ID and Sigfox PAC from the last screen of firmware updater.\n\nSigfox ID and Sigfox Pac is assigned to your device just once during the first update process. Sigfox ID and Sigfox Pac will not change after successive firmware updates.\nAfter first firmware update you can also get your Sigfox ID and Sigfox PAC through a couple of commands via the REPL.\nfrom network import Sigfox\nimport binascii\n\n# initalise Sigfox for RCZ1 (You may need a different RCZ Region)\nsigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)\n\n# print Sigfox Device ID\nprint(binascii.hexlify(sigfox.id()))\n\n# print Sigfox PAC number\nprint(binascii.hexlify(sigfox.pac()))\n\nCreating account at Sigfox backend\nYou need to register to the Sigfox Backend. Navigate to https://backend.sigfox.com/activate\n\nFind the specific country country where the device will be activated. Enter the device's Sigfox ID and Sigfox PAC.\nYou should see green microchip if you entered correct Sigfox ID and Sigfox PAC\n\nThen provide the required information including email address and complete registration.\nWhen registering your other devices (not your first device), you already have created Sigfox Account before. Be sure you are login with your Sigfox account. In that way all of your devices will be added to same Sigfox Account.\n\n\nAfter registration, you will receive confirmation email with password to Sigfox backend https://backend.sigfox.com/auth/login\nUse your email and password to login to Sigfox backend.\n\nIf you enter correct credentials then you should be able to login to Sigfox backend.\nTransferring your device to new Sigfox account\nYou may want to transfer your devices to new Sigfox account.\nOnce you register your device on Sigfox backend, then your Sigfox PAC was used, and is not valid anymore. You need to get new Sigfox PAC. We don't update Sigfox PAC assigned to your device (which can be seen on last page of Firmware updater or read from device).\nTo get new Sigfox PAC navigate to your device on Sigfox backend. On device click on Sigfox Id of device you want to transfer.\n\nNow you can see your new Sigfox PAC.\n\nOnce you know your new Sigfox PAC go to https://backend.sigfox.com/activate and register device with different account.\n"},"gettingstarted/registration/cellular.html":{"url":"gettingstarted/registration/cellular.html","title":"Cellular","keywords":"","body":"Cellular\nIn order to use your GPy/FiPy on a cellular network you are required to get a SIM card from a local provider.\nNote: This might differ from a standard SIM you can buy in a store, our devices do not support standard LTE.\nCurrently we are not able to provide any specific details about how to get such a SIM card and how to register it as most deployments are closed trials, each carrier has it's own rules (for example, whether they require special SIMs or not).\nWe recommend contacting your local cellular providers to check their plans surrounding LTE CAT-M1 and NB-IoT. By contacting them, you will show the carriers that there is local interest in deploying such networks.\nYou can find a map of deployed networks and open labs here.\n"},"gettingstarted/registration/lora/":{"url":"gettingstarted/registration/lora/","title":"LoRaWAN","keywords":"","body":"LoRaWAN\nRaw LoRa\nWhen using raw LoRa, you do not have to register your module in any way. The modules can talk to each other directly.\nLoRaWAN\nIn order to connect your LoRa capable Pycom module to a LoRaWAN network you will have to register your device with the desired network. We are unable to provide instructions for all LoRaWAN networks but below you will find some generic instructions, along with links to any specific guides we are aware of.\nGeneric instructions\nFirstly you will need to get your modules Device EUI, this can be achieved using the following code:\nfrom network import LoRa\nimport ubinascii\n\nlora = LoRa(mode=LoRa.LORAWAN)\nprint(ubinascii.hexlify(lora.mac()).upper().decode('utf-8'))\n\nThe output will be a hex string like: 70B3D5499585FCA1. Once you have this you will need to provide it to your LoRaWAN network which will then provide you with the details need to connect via Over-the-Air Activation (OTAA) or Activation by Personalisation (ABP)\nOTAA\nIf you wish to connect via OTAA (which is the recommended method) the network will provide you with an Application EUI and Application Key. The former identifies what application your device is connecting to, the latter is a shared secret key unique to your device to generate the session keys that prove its identity to the network. Once you have these you can use the LoRaWAN OTAA example code to connect to the network.\nABP\nWith ABP the encryption keys enabling communication with the network are preconfigured in the device. The network will need to provide you with a Device Address, Network Session Key and Application Session Key. Once you have these you can use the LoRaWAN ABP example code to connect to the network.\nNetworks\n\n\nIf you cannot find your favourite LoRaWAN network in the list above, please consider writing a tutorial for how to connect a Pycom module with it and contribute it to this documentation via a GitHub pull request.\n\n"},"gettingstarted/registration/lora/ttn.html":{"url":"gettingstarted/registration/lora/ttn.html","title":"The Things Network","keywords":"","body":"The Things Network\nIn order to use The Things Network (TTN) you should navigate to their website and create/register an account. Enter a username and an email address to verify with their platform.\n\nOnce an account has been registered, you can register your Pycom module as either a node or a nano-gateway. The steps below will detail how to do this.\nCreate an application\nIn order to register your device to connect to the things network, you must first create an application for these devices to belong to. This way the Network will know where to send the devices data to.\nSelecting the Applications tab at the top of the TTN console, will bring up a screen for registering applications. Click register and a new page, similar to the one below, will open.\n\nEnter a unique Application ID as well as a Description & Handler Registration.\nNow the Pycom module nodes can be registered to send data up to the new Application.\nRegister a Device\nTo connect nodes to a things network gateway, devices need to be added to the application. To do this, navigate to the Devices tab on the Application home page and click the Register Device button.\n\nIn the Register Device panel, complete the forms for the Device ID and the Device EUI. The Device ID is user specified and is unique to the device in this application. The Device EUI should be a globally unique identifier for the device. You can run the following on you Pycom module to retrieve its EUI.\nfrom network import LoRa\nimport ubinascii\n\nlora = LoRa()\nprint(\"DevEUI: %s\" % (ubinascii.hexlify(lora.mac()).decode('ascii')))\n\nOnce the device has been added, change the Activation Method between OTAA and ABP depending on user preference. This option can be found under the Settings tab.\nRegister a Nano-Gateway\nYou can also setup your Pycom module to act as a gateway with The Things Network. The code required to do this can be found here.\nInside the TTN Console, there are two options, Applications and Gateways. Select Gateways and then click on register Gateway. This will allow for the set up and registration of a new nano-gateway.\n\nOn the Register Gateway page, you will need to set the following settings:\n\nThese are unique to each gateway, location and country specific frequency. Please verify that correct settings are selected otherwise the gateway will not connect to TTN.\nYou need to tick the \"I'm using the legacy packet forwarder\" to enable the right settings. This is because the Nano-Gateway uses the 'de facto' standard Semtech UDP protocol.\n\n\n\nOption\nValue\n\n\n\n\nProtocol\nPacket Forwarder\n\n\nGateway EUI\nUser Defined (must match config.py)\n\n\nDescription\nUser Defined\n\n\nFrequency Plan\nSelect Country (e.g. EU - 868 MHz)\n\n\nLocation\nUser Defined\n\n\nAntenna Placement\nIndoor or Outdoor\n\n\n\nMost LoRaWAN network servers expect a Gateway ID in the form of a unique 64-bit hexadecimal number (called a EUI-64). The recommended practice is to produce this ID from your board by expanding the WiFi MAC address (a 48-bit number, called MAC-48). You can obtain that by running this code prior to configuration:\n from network import WLAN\n import binascii\n wl = WLAN()\n binascii.hexlify(wl.mac())[:6] + 'FFFE' + binascii.hexlify(wl.mac())[6:]\n\nOnce these settings have been applied, click Register Gateway. A Gateway Overview page will appear, with the configuration settings showing. Next click on the Gateway Settings and configure the Router address to match that of the gateway (default: router.eu.thethings.network).\n\nThe Gateway should now be configured.\n"},"gettingstarted/registration/lora/senet.html":{"url":"gettingstarted/registration/lora/senet.html","title":"Senet","keywords":"","body":"Senet\n\nThe Senet Developer Portal\nConnecting your device begins by creating an account on the Senet Developer Portal. This will grant you free access for up to 10 devices and 5 gateways to support application development activities. Sign-Up\nComplete Senet Developer Portal documentation is available on line at Docs.\nOnce your account has been activated, you may want to onboard a gateway, if Senet public network access in unavailable. Onboarding your device consists of registering the device through your portal account and then provisioning your device with the information provided at the completion of the registration process. Senet supports both Over-The-Air-Activation (OTAA) and Activation-By-Personalization (ABP). As ABP is useful only in a very narrow set of use-cases, this tutorial will walk you through OTAA registration and provisioning.\nDevice Identity and Security Elements\nAll LoRaWAN 1.0.x end-devices require three provisioning elements to join a network. Devices typically come from the factory with a unique, 64-bit EUI (called a DevEUI) which is the device's globally unique identifier. In the case of the Senet Developer Portal, the two additional elements (The Application EUI or AppEUI and Application Key or AppKey) will be generated and provided to you after registration (in typical production environments, these additional elements are also provided during manufacturing and provisioned into the network backend).\n\nDevice EUI (DevEUI)\nApplication EUI (AppEUI)\nApplication Key (AppKey)\n\nDevice EUI\nThis comes from the device itself and can be obtained from lora.mac().To obtain the required hexadecimal representation you can run the following code on your LoPy:\nfrom network import LoRa\nimport ubinascii\n\nlora = LoRa()\nprint(\"DevEUI: %s\" % (ubinascii.hexlify(lora.mac()).decode('ascii')))\n\nUse this value during the first step of device registration.\n\nApplication EUI and Application Key\nThe Application EUI uniquely identifies the security broker (called a Join Server in LoRaWAN terminology) which is interogated by the network when the device attempts to join the network. The Application Key is the shared secret (between the end-device and the Join-Server) which forms the basis for LoRaWAN security and is used to generate the application and network session keys used for privacy and message integrity.\nAt the completion of your device registration process on the Senet Developer Portal, you will be presented with the Application EUI and the Application Key which you will need to provision in your device. This information is always available after the fact in the device details screen.\n\nProvisioning the LoPy or FiPy\nAfter device registration is complete, configure the device for optimal operation and provision the AppEUI and AppKey.\nfrom network import LoRa\nimport socket\nimport time\nimport ubinascii\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.US915)\n\n# create an OTAA authentication parameters\napp_eui = ubinascii.unhexlify('00250C0000010001')\napp_key = ubinascii.unhexlify('00112233445566778899AABBCCDDEEFF')\n\n# initialize LoRa\nlora.init(mode=LoRa.LORAWAN, adr=True, public=True)\n\n# join a network using OTAA (Over the Air Activation)\nlora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), dr=0, timeout=0)\n\nYou are now ready to start sending messages from your device! Each device may be provisioned to stream the datagrams to the backend service of your choice in a variety of standard and custom formats.\n"},"gettingstarted/troubleshooting-guide.html":{"url":"gettingstarted/troubleshooting-guide.html","title":"Troubleshooting Guide","keywords":"","body":"Troubleshooting Guide\nHow to ask for help\nAlways provide these details when asking for help. This helps us understand your setup and save time.\n\nRun os.uname() on your module to get the version numbers\nYour module's type & version (e.g. FiPy 1.0)\nAny shields, or devices connected (e.g. Pytrack, Extension Board 3.0 with “x\" sensor)\nYour Operating System's version\nPymakr version\nAtom / VSCode version\nHave you looked at our documentation and similar issues on the forum?\n\nFirmware Update\nFirmware file has unexpected sha1 checksum.\nIf you're trying to update to the latest development firmware, make sure you use the development release of the Firmware Updater.\nMy module is recognised as the wrong type\nOpen a support ticket with the details and send us the result of this code:\nimport machine, binascii \nbinascii.hexlify(machine.unique_id())\n\nConnecting to the module\nModule stuck in bootloader mode\nNormally, the firmware updater switches back to application mode at the end of an upgrade. If that doesn't happen for some reason, re-plugging the USB cable also puts the device back into application mode.\nPymakr\nMake sure you have the latest version of Pymakr and Atom/VSCode installed.\nSynchronising a project results in ‘Failed to allocate memory' error\nSynchronising takes a bit of memory, so this error can occur when code running on the board already is taking a substantial amount of memory.\nSolution: use safe boot with REPL or Expansion Board when synchronising\nAtom\nFailed to load package: Cannot find module ‘serialport'\nIn some cases, this is caused by the Atom Package Manager (apm) using Python 3.x, while node-gyp (used for compiling the serialport lib) needs Python 2.x. To confirm this, apm —version can be run to check which Python version apm is using.\nSolution: Tell the package manager to use python 2 instead. Running the following command switches apm to 2.7:\necho “python=/usr/bin/python2.7” >> ~/.atom/.apmrc\n\nNow reinstall Pymakr or run apm install from the Pymakr package located in ~/.atom/packages/pymakr\nCould not locate the bindings file\nIf the installation of the serialport library failed, it reverts back to the precompiled version that is included in the plugin. This is compiled for the latest versions of Atom and loses compatibility with older versions.\nSolution: upgrade to the latest Atom (1.19.0 or higher) or install the previous version of the plugin (apm install pymakr@1.0.3)\nAny error where the traceback contains .atom\\packages\\Pymakr\\ with a capital “P”\nThis happened after Pymakr renamed to pymakr (lowercase) starting at version 1.2.5, but Atom remembers the old folder name inside the packages folder.\nSolution:\n\nUninstall Pymakr\nRemove folder: ~/.atom/.apm/Pymkr\nEmpty folder: ~/.config/Atom/Cache\nReinstall pymakr\n\nCannot connect to Pycom board via REPL\nIn the case of a board that has already has code uploaded to it and is running a loop/non-exiting script, the board may not boot into a REPL.\nSolution: If the board is currently running code, you will need to exit the current script before proceeding: 1. Ensure your board is connected to your computer 2. Press the reset button on the device 3. Press ctrl-c on within the Pymakr console to exit the current script/program\nThe REPL should then appear with the >>> prompt and you will be able to run/sync your code.\nCannot connect to Pycom on Linux\nIf you're a Linux user and can't connect to your board, there might be a permission issue to access the serial port.\nSolution: Run the following command sudo usermod -a -G dialout $USER\nVSCode\nTerminal not opening\nIf the Pymakr terminal is not opening or giving an error, this might be because NodeJS is not installed on your system. This is because the terminal process is running separate from VSCode and depends on your systems NodeJS install.\nSolution: install NodeJS. For Windows 64 machines, install a 32 bit version of NodeJS (for example nvm install 7.8.0 32 when using nvm).\n"},"pymakr/installation/":{"url":"pymakr/installation/","title":"Installation","keywords":"","body":"Installation\n\nPymakr Plugins \nTo make it as easy as possible Pycom has developed a plugin for two popular text editors, called Pymakr. These plugins have been built and are available for the following platforms:\n"},"pymakr/installation/atom.html":{"url":"pymakr/installation/atom.html","title":"Atom","keywords":"","body":"Atom\nFor beginners, users getting started with MicroPython & Pycom as well as Atom text editor users, we recommend the Pymakr Plugin for Atom. This section will help you get started using the Atom Text Editor & Pymakr Plugin.\nPlease follow these steps to install the Pymakr Plugin:\n\nEnsure that you have the latest Atom installed and open.\n\n\n\nNavigate to the Install page, via Atom > Preferences > Install\n\n\n\nSearch for Pymakr and select the official Pycom Pymakr Plugin.\n\n\n\nYou should now see and click the Install button. This will download and install the Pymakr Plugin.\n\n\n\nThat's it! You've installed the Pymakr Plugin for Atom.\n\n\nConnecting via Serial USB\nAfter installing the Pymakr Plugin, you need to take a few seconds to configure it for first time use. Please follow these steps:\n\nConnect your Pycom device to your computer via USB. If you are using an Expansion Board 2.0, and have just finished a firmware upgrade, be sure to remove the wire between GND and G23 and reset your device by pressing the button.\nNote: you don't need the wire for Expansion Board 3.0\n\nOpen Atom and ensure that the Pymakr Plugin has correctly installed.\n\n\n\n\nOpen the Pymakr console by clicking the ^ button, located in the lower right side of the Atom window.\n\n\n\nClick, More followed by Get Serial Ports. This will copy the serial address of your expansion board to your clipboard.\n\n\n\nNavigate to Settings > Global Settings\n\n\n\nPaste the serial address you copied earlier into the text field Device Address\n\n\n\nPress connect and the Pymakr console should show three arrows >>>, indicating that you are connected\n\n\nThese settings can also be applied on a per project basis by clicking Settings then Project Settings. This will open a JSON file which you can edit to enter your desired settings.\nThis process is easiest with either a Pycom Expansion Board or a Pytrack/Pysense as the addresses are automatically selected. For external products such as FTDI USB Serial Cables, the serial address may need to be copied manually. Additionally, the reset button on the device may also need to be pressed before a connection message appears.\n\nConnecting via Telnet\nAfter installing the Pymakr Plugin, a device may be connected via the telnet interface. Please see the following steps:\n\nEnsure that Pycom device is turned on\nConnect the host computer to the WiFi Access Point named after your board (the SSID will be as follows e.g. lopy-wlan-xxxx, wipy-wlan-xxxx, etc.). The password is www.pycom.io.\nFollow the steps as above in the \"Connecting via Serial USB\" section but\nenter 192.168.4.1 as the address.\n\nThe default username and password are micro and python, respectively.\n\nClick Connect in the Pymakr pane, Pymakr will now connect via telnet.\n\n\n"},"pymakr/installation/vscode.html":{"url":"pymakr/installation/vscode.html","title":"Visual Studio Code","keywords":"","body":"Visual Studio Code\nPycom also supports Microsoft's Visual Studio Code IDE platform with the Pymakr Plugin. To download Visual Studio Code, navigate to VS Code.\nYou will also need NodeJS installed on your PC. Please download the latest LTS version available from the NodeJS website.\nPlease follow these steps to install the Pymakr VSCode Extension:\n\nEnsure that you have the latest VSCode installed and open.\n\n\n\nNavigate to the Extensions page, using the 5th button in the left navigation\n\n\n\nSearch for Pymakr and click the install button next to it.\n\n\n\nWithin a few minutes, a reload button should appear. Press it to reload VSCode.\n\n\n\nThat's it! You've installed the Pymakr Extension for VSCode\n\n\nConnecting via Serial USB\nAfter installing the Pymakr Plugin, you need to take a few seconds to configure it for first time use. Please follow these steps:\n\nConnect your Pycom device to your computer via USB. If you are using an\nExpansion Board, and have just finished a firmware upgrade, be sure to Remove\nthe wire between GND and G23 and reset your device by pressing the button.\n\nOpen Visual Studio Code and ensure that the Pymakr Plugin has correctly installed.\n\n\n\n\nClick All commands on the bottom of the Visual Studio Code window\n\n\n\nIn the list that appears, click Pymakr > Extra > List Serial Ports\n\n\n\nThis will list the available serial ports. If Pymakr is able to auto-detect which to use, this will be copied to your clipboard. If not please manually copy the correct serial port.\n\n\n\nOnce again click All commands, then click Pymakr > Global Settings. This will open a JSON file. Paste the serial address you copied earlier into the field address and save the file.\n\n\n\nFinally close the JSON file, click All commands, then Pymakr > Connect to connect your device. The Pymakr console should show three arrows >>>, indicating that you are connected\n\n\nThese settings can also be applied on a per project basis by clicking All commands then Pymakr > Project Settings. This will open a JSON file which you can edit to enter your desired settings for the currently open project.\nThis process is easiest with either a Pycom Expansion Board or a Pytrack/Pysense as the addresses are automatically selected. For external products such as FTDI USB Serial Cables, the serial address may need to be copied manually. Additionally, the reset button on the device may also need to be pressed before a connection message appears.\n\nConnecting via Telnet\nAfter installing the Pymakr Plugin, a device may be connected via the telnet interface. Please see the following steps:\n\nEnsure that Pycom device is turned on\nConnect the host computer to the WiFi Access Point named after your board\n(the SSID will be as follows e.g. lopy-wlan-xxxx, wipy-wlan-xxxx, etc.).\nThe password is www.pycom.io.\n\nFollow the steps as above in the \"Connecting via Serial USB\" section but\nenter 192.168.4.1 as the address.\n\nThe default username and password are micro and python,\nrespectively.\n\nFinally close the JSON file, click All commands, then Pymakr > Connect,\nPymakr will now connect via telnet.\n\n\n"},"pymakr/toolsfeatures.html":{"url":"pymakr/toolsfeatures.html","title":"Tools/Features","keywords":"","body":"Tools/Features\nConsole (REPL)\nMicroPython has an interactive code tool known as the REPL (Read Evaluate Print Line). The REPL allows you to run code on your device, line by line. To begin coding, go to the Pymakr Plugin Console and start typing your code. Start by making the LED change colour.\nimport pycom # we need this module to control the LED\n\npycom.heartbeat(False) # disable the blue blinking\npycom.rgbled(0x00ff00) # make the LED light up green in colour\n\nYou can change the colour by adjusting the hex RGB value.\npycom.rgbled(0xff0000) # now make the LED light up red in colour\n\nThe console can be used to run any python code, also functions or loops.\nUse print() to output contents of variables to the console for you to read. Returned values from functions will also be displayed if they are not caught in a variable. This will not happen for code running from the main or boot files. Here you need to use print() to output to the console.\nNote that after writing or pasting any indented code like a function or a while loop, the user will have to press enter up to three times to tell MicroPython the code is to be closed (this is standard MicroPython & Python behaviour).\nAlso be aware that code written into the REPL is not saved after the device is powered off/on again.\n\nRun\nTo test code on a device, create a new .py file or open an existing one, type the desired code, save the file and then press the Run button. This will run the code directly onto the Pycom board and output the results of the script to the REPL.\nChanges made to files won't be automatically uploaded to the board upon restarting or exiting the Run feature, as the Pycom board will not store this code. In order to push the code permanently to a device, use the Upload feature.\n\nProjects\nPymakr Plugin supports user projects, allowing for pre-configured settings such as default serial address/credentials, files to be ignored and folders to sync.\npymakr.conf\nPymakr Plugin supports local project settings using a file called pymakr.conf. This can be used to store the default serial address of a device, which files to ignore and other settings. An example pymakr.conf is shown below:\n{\n \"address\": \"/dev/cu.usbserial-AB001234\",\n \"username\": \"micro\",\n \"password\": \"python\",\n \"sync_folder\": \"scripts\"\n}\n\nUpload\nThe Pymakr Plugins have a feature to sync and upload code to a device. This can be used for both uploading code to a device as well as testing out scripts by running them live on the device. The following steps demonstrate how to use this feature.\nTo start using the Upload feature, ensure that a project folder has been created for the device. For example, if using the pymakr.conf from above, this project folder should be named scripts. This folder should have the following structure:\n\nLibrary files should be placed into the lib folder, certificates into the cert folder and so on. The Upload button will take the highest level folder (currently open) and upload this to the connected Pycom device. The files will be pushed to the device in exactly the same structure as within the code editor's file directory.\nMore\nClicking the More button within the Pymakr Plugin allows for some additional features. See the options below for specific functionality.\nGet Firmware Version\nRetrieves the firmware version of the Pycom device connected to the Pymakr Plugin instance.\nGet WiFi AP SSID\nRetrieves the default WiFi Access Point SSID of the Pycom device connected to the Pymakr Plugin instance.\nGet Serial Ports\nRetrieves the various serial ports that are available to the Pymakr Plugin instance.\n"},"pymakr/settings.html":{"url":"pymakr/settings.html","title":"Settings","keywords":"","body":"Settings\nBelow you will find a description of the various settings available for Pymakr.\naddress\nThis is the address of the Pycom module you want Pymakr can connect to. This can be either a serial port (e.g COM1 on windows or /dev/cu.usbserial-DQ0054ES on Linux/macOS) or an IP address (Telnet) (e.g. 192.168.4.1 if connected to the AP created by the Pycom module).\nusername\nIf a IP address was provided for the address therefore Pymakr is connecting via Telnet, you will also need to provide a username, the default is micro.\npassword\nIf an IP address was provided for the address, Pymakr is connecting via Telnet. You will also need to provide a password, the default is python.\nsync_folder\nIf left blank, all directories inside the project will be synced to the device when the user clicks upload. If directories are specified, only these directories will be synced, all others will be ignored\nopen_on_start\nIf set to true, the Pymakr console will open and try to connect when the editor is started, or a project is opened.\nsafe_boot_on_upload\nIf set to true, Pymakr will reboot the connected device into safe-mode before uploading. This is useful if your code uses a lot of RAM causing issues with the upload procedure.\nThis feature is only available on modules running firmware version 1.17.0.b1 or higher.\nsync_file_types\nOnly files ending with the extensions listed in this setting will be synced to the device when performing an upload. All other files are ignored. By default this is set to include: py, txt, log, json, xml\nctrl_c_on_connect\nIf set to true, Pymakr will sent the ctrl-c signal to the connected module before uploading. This should stop the script currently running on the device and improve the reliability of the upload process.\n"},"pytrackpysense/introduction.html":{"url":"pytrackpysense/introduction.html","title":"Introduction","keywords":"","body":"Introduction\nIn addition to the Expansion Board, Pycom also offers three additional sensor boards, which are ideal for quickly building a fully functioning IoT solution! Whether the application is environment sensing or asset tracking, these additional boards support a variety of sensors.\nPytrack\nPytrack is a location enabled version of the Expansion Board, intended for use in GPS applications such as asset tracking or monitoring.\n\nFeatures & Hardware\nThe Pytrack is has a number of features including GPS, 3-Axis Accelerometer and Battery Charger. See the list below for detailed specifics about each sensor, including datasheets.\n\nSerial USB\n3-Axis Accelerometer (LIS2HH12)\nBattery Charger (BQ24040 with JST connector)\nGPS and GLONASS (L76-L)\nMicroSD Card Reader\n\nAll of the included sensors are connected to the Pycom device via the I2C interface. These pins are located at P22 (SDA) and P21 (SCL).\nYou can find the datasheet and more info here:\nPysense\nPysense is a sensor packed version of the Expansion Board, intended for use in environment sensing applications such as temperature, humidity monitoring, and light sensing.\n\nFeatures & Hardware\nThe Pysense is packed with a number of sensors and hardware, see the list below for detailed specifics about each sensor, including datasheets.\n\nSerial USB\n3-Axis Accelerometer (LIS2HH12)\nBattery Charger (BQ24040 with JST connector)\nDigital Ambient Light Sensor (LTR-329ALS-01)\nHumidity and Temperature Sensor (SI7006-A20)\nBarometric Pressure Sensor with Altimeter (MPL3115A2)\nMicroSD Card Reader\n\nAll of the included sensors are connected to the Pycom device via the I2C interface. These pins are located at GPI09 (SDA) and GPI08 (SCL).\nYou can find the datasheet and more info here:\nPyscan\nPyscan is a RFID-NFC enabled version of the Expansion Board, intended for use in scanning applications, such as RFID/NFC readers.\n\nFeatures & Hardware\nThe Pyscan is packed with a number of sensors and hardware, see the list below for detailed specifics about each sensor, including datasheets.\n\n3-Axis Accelerometer (LIS2HH12)\nDigital Ambient Light Sensor (LTR-329ALS-01)\nRFID-NFC Chip (MFRC63002HN)\nSerial USB\nBattery Charger (BQ24040 with JST connector)\nMicroSD Card Reader\nUltra low power operation (~1uA in deep sleep)\n\nAll of the included sensors are connected to the Pycom device via the I2C interface. These pins are located at P22 (SDA) and P21 (SCL).\nYou can find the datasheet and more info here:\n"},"pytrackpysense/installation/":{"url":"pytrackpysense/installation/","title":"Installing Software","keywords":"","body":"Installing Software\nAs the development for these devices are on going with additional features being added, every week, it is essential to ensure you frequently check for updates on the Pytrack/Pysense/Pyscan. As well as updating the device firmware, it is important to check the GitHub repository for the respective library files as they as also being updated, to include additional features/functionality.\n"},"pytrackpysense/installation/firmware.html":{"url":"pytrackpysense/installation/firmware.html","title":"Updating Firmware","keywords":"","body":"Updating Firmware\nTo update the firmware on the Pysense/Pytrack/Pyscan/Expansion Board v3, please see the following instructions. The firmware of Pysense/Pytrack/Pyscan/Expansion Board v3 can be updated via the USB port using the terminal tool, DFU-util.\nThe latest firmware DFU file can be downloaded from the links below:\n\nPytrack DFU\nPysense DFU\nExpansion Board DFU\n\nWhile in the normal, application mode, the Pysense/Pytrack/Pyscan/Expansion Board v3 require a Serial USB CDC driver, in DFU, bootloader mode, the DFU driver is required. Below, the USB Product ID is depicted for each case.\n\n\n\nBoard\nDFU bootloader (update mode)\nApplication firmware (normal mode)\n\n\n\n\nPytrack\n0xF014\n0xF013\n\n\nPysense\n0xF011\n0xF012\n\n\nPyscan\n0xEF37\n0xEF38\n\n\nExpansion Board v3\n0xEF99\n0xEF98\n\n\n\nNote: USB Vendor ID is always 0x04D8.\nInstalling the DFU-util Tools\nmacOS\nIf using homebrew:\n$ brew install dfu-util\n\nIf using MacPorts:\nport install libusb dfu-util\n\nLinux\nUbuntu or Debian:\n$ sudo apt-get install dfu-util\n\nFedora:\n$ sudo yum install dfu-util\n\nArch:\n$ sudo pacman -Sy dfu-util\n\nWindows\n\nDFU-util v0.9 – Tool to upload the firmware to the Pytrack/Pysense\nZadig – Installer tool for the Pytrack/Pysense board DFU Firmware\n\nTo uploaded the latest DFU firmware to the Pytrack/Pysense, first install the DFU drivers to the host computer. Open Zadig and select libusbK as the driver.\nTo install the drivers, the Pytrack/Pysense board must be in DFU-mode:\n\nDisconnect the USB cable\nHold down the button on the shield\nConnect the USB cable\nKeep the button pressed for at least one second\nRelease the button. When the board is connected in DFU-mode, it will be in this state for 7 seconds.\nClick the“Install Driver button immediately. If the driver was unsuccessful, repeat from step 1.\nHere the USB ID has to be the DFU-bootloader one (0xF014for Pytrack or 0xF011 for Pysense).\nThis is a successful DFU driver installation for Pytrack:\n\n\n\n\nOpen the command prompt and navigate to the directory where the DFU-util and the firmware was downloaded (must be in same directory). Repeat the procedure to get the board in DFU-mode and run the command below but replace X.X.X with the firmware version and replace Pysense with Pytrack if it is the Pytrack that is to be updated (e.g: pytrack_0.0.8.dfu):\ndfu-util-static.exe -D pysense_X.X.X.dfu\n\nIf the update was successful, a message,\"Done!\" should appear in the bottom of the command prompt.\nDouble-check Serial USB (CDC) driver is installed in Application mode: if, by mistake, the libusbk driver was installed while the USB ID is the Application mode (0xF013 for Pytrack or 0xF012 for Pysense), then the Serial USB (CDC) driver has to be installed for application mode. This will allow Windows to allocate a COM port, which is required for REPL console.\n\nUsing DFU-util with Pytrack, Pysense and Expansion Board v3\nTo enter update mode follow these steps:\n\nUnplug the device\nPress the button and keep it held (on the Expansion Board the S1 button)\nPlug in the USB cable to the host computer and wait 1 second before releasing the button\nAfter this you will have approximately 7 seconds to run the DFU-util tool\n\nmacOS and Linux:\n$ dfu-util -D pytrack_0.0.8.dfu\n\nYou might need to run dfu-util as sudo. In that case, you will need to enter your password.\n\nAn output, similar to the one below, will appear upon successful installation:\ndfu-util 0.9\n\nCopyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.\nCopyright 2010-2016 Tormod Volden and Stefan Schmidt\nThis program is Free Software and has ABSOLUTELY NO WARRANTY\nPlease report bugs to http://sourceforge.net/p/dfu-util/tickets/\n\nMatch vendor ID from file: 04d8\nMatch product ID from file: f014\nOpening DFU capable USB device...\nID 04d8:f014\nRun-time device DFU version 0100\nClaiming USB DFU Runtime Interface...\nDetermining device status: state = dfuIDLE, status = 0\ndfu-util: WARNING: Runtime device already in DFU state ?!?\nClaiming USB DFU Interface...\nSetting Alternate Setting #0 ...\nDetermining device status: state = dfuIDLE, status = 0\ndfuIDLE, continuing\nDFU mode device DFU version 0100\nDevice returned transfer size 64\nCopying data from PC to DFU device\nDownload [=========================] 100% 16384 bytes\nDownload done.\nstate(2) = dfuIDLE, status(0) = No error condition is present\nDone!\n\nDebugging\nUsing lsusb command, the Pytrack/Pysense device should be visible in both normal and bootloader modes.\nFor exemple, a Pytrack board is visible as either:\n\nBus 020 Device 004: ID 04d8:f014 Microchip Technology Inc. Application Specific Device\nthis is bootloader mode (f014 is USB PID), active just for 7-8 seconds, if the reset button was just pressed before plugging USB connector.\n\n\nBus 020 Device 005: ID 04d8:f013 Microchip Technology Inc. Pytrack Serial: Pyabcde0\nthis is normal, application mode (f013 is USB PID), this means the bootloader verified application partition and it boot-up correctly.\n\n\n\n"},"pytrackpysense/installation/drivers.html":{"url":"pytrackpysense/installation/drivers.html","title":"Installing Drivers - Windows 7","keywords":"","body":"Installing Drivers - Windows 7\nPytrack and Pysense will work out of the box for Windows 8/10/+, macOS as well as Linux. If using Windows 7, drivers to support the boards will need to be installed.\nPlease follow the instructions below to install the required drivers.\nDownload\nPlease download the driver software from the link below.\nPytrack/Pysense/Pyscan/Expansion Board 3 Driver\nInstallation\nFirst navigate open the Windows start menu and search/navigate to Device Manager. You should see your Pytrack/Pysense in the dropdown under other devices.\n\nRight click the device and select Update Driver Software.\n\nSelect the option to Browse my computer for driver software.\n\nNext you will need to navigate to where you downloaded the driver to (e.g. Downloads Folder).\n\nSpecify the folder in which the drivers are contained. If you haven't extracted the .zip file, please do this before selecting the folder.\n\nYou may receive a warning, suggesting that windows can't verify the publisher of this driver. Click Install this driver software anyway as this link points to our official driver.\n\nIf the installation was successful, you should now see a window specifying that the driver was correctly installed.\n\nTo confirm that the installation was correct, navigate back to the Device Manager and click the dropdown for other devices. The warning label should now be gone and Pytrack/Pysense should be installed.\n\n"},"pytrackpysense/installation/libraries.html":{"url":"pytrackpysense/installation/libraries.html","title":"Installing Libraries","keywords":"","body":"Installing Libraries\nTo utilise the sensors on the Pytrack and Pysense, Pycom has written libraries to make reading to/from the various sensors accessible via an API. These libraries reside at the Pycom GitHub repository and the latest versions can be found under the releases page.\nGitHub Repository\nDownload the repository as a .zip file, navigate to the correct device (Pysense/Pytrack), extract the files and then upload the desired files to the device in the instructions below.\nUploading the Libraries to a Device\nThese libraries should be uploaded to a device (LoPy, SiPy, WiPy 2.0, etc.) in the same process as a standard MicroPython library. The various .py files should be placed into the /lib folder on the device. For example, if using the Pysense and the user wishes to enable the only Accelerometer and the Light Sensor, they should place the following .py files into the device's /lib folder:\n- pysense.py\n- LIS2HH12.py\n- LTR329ALS01.py\n\nAdd as many or as few of the libraries that are required.\nIn addition to the Pysense or Pytrack specific libraries, you also need to upload the pycoproc.py file from the _lib/pycoproc_ folder inside the libraries archive.\nThe Pytrack and Pysense boards behave the same as the Expansion Board. Upload, Run and upload code to Pycom modules via the Pymakr Plugin, in exactly the same process.\n\nImporting/Using the Libraries\nOnce the libraries are uploaded to the device, they can be used/imported as a typical MicroPython library would be. For example, importing and using the light sensor on the Pysense:\nfrom pysense import Pysense\nfrom LTR329ALS01 import LTR329ALS01\n\npy = Pysense()\nlt = LTR329ALS01(py)\n\nprint(lt.light())\n\n"},"pytrackpysense/apireference/":{"url":"pytrackpysense/apireference/","title":"API Reference","keywords":"","body":"API Reference\nTo simplify usability, APIs for the libraries have been created, abstracting away the low level interactions with the sensors. The next following pages refer to the respective libraries for the Pytrack, Pysense, and Pyscan.\n"},"pytrackpysense/apireference/pytrack.html":{"url":"pytrackpysense/apireference/pytrack.html","title":"Pytrack","keywords":"","body":"Pytrack\nThis chapter describes the various libraries which are designed for the Pytrack board. This includes details about the various methods and classes available for each of the Pytrack's sensors.\n3-Axis Accelerometer (LIS2HH12)\nPytrack has a 3-Axis Accelerometer that provides outputs for acceleration as well as roll, pitch and yaw.\nConstructors\nclass LIS2HH12(pytrack = None, sda = 'P22', scl = 'P21')\nCreates a LIS2HH12 object, that will return values for acceleration, roll, pitch and yaw. Constructor must be passed a Pytrack or I2C object to successfully construct.\nMethods\nLIS2HH12.acceleration()\nRead the acceleration from the LIS2HH12. Returns a tuple with the 3 values of acceleration (G).\nLIS2HH12.roll()\nRead the current roll from the LIS2HH12. Returns a float in degrees in the range -180 to 180.\nLIS2HH12.pitch()\nRead the current pitch from the LIS2HH12. Returns a float in degrees in the range -90 to 90. Once the board tilts beyond this range the values will repeat. This is due to a lack of yaw measurement, making it not possible to know the exact orientation of the board.\nGPS with GLONASS (Quectel L76-L GNSS)\nPytrack has a GPS (with GLONASS) that provides outputs longitude/latitude, speed and other information about the Pytrack's location.\nConstructors\nclass L76GNSS(pytrack = None, sda = 'P22', scl = 'P21', timeout = None)\nCreates a L76GNSS object, that will return values for longitude and latitude. Constructor must be passed a Pytrack or I2C object to successfully construct. Set the timeout to a time period (in seconds) for the GPS to search for a lock. If a lock is not found by the time the timeout has expired, the coordinates method will return (None, None).\nMethods\nL76GNSS.coordinates(debug = False)\nRead the longitude and latitude from the L76GNSS. Returns a tuple with the longitude and latitude. With debug set to True the output from the GPS is verbose.\nPlease note that more functionality is being added weekly to these libraries. If a required feature is not available, feel free to contribute with a pull request at the Libraries GitHub repository\n\n"},"pytrackpysense/apireference/pysense.html":{"url":"pytrackpysense/apireference/pysense.html","title":"Pysense","keywords":"","body":"Pysense\nThis chapter describes the various libraries which are designed for the Pysense board. This includes details about the various methods and classes available for each of the Pysense's sensors.\n3-Axis Accelerometer (LIS2HH12)\nPysense has a 3-Axis Accelerometer that provides outputs for acceleration as well as roll, pitch and yaw.\nConstructors\nclass LIS2HH12(pysense = None, sda = 'P22', scl = 'P21')\nCreates a LIS2HH12 object, that will return values for acceleration, roll, pitch and yaw. Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nLIS2HH12.acceleration()\nRead the acceleration from the LIS2HH12. Returns a tuple with the 3 values of acceleration (G).\nLIS2HH12.roll()\nRead the current roll from the LIS2HH12. Returns a float in degrees in the range -180 to 180.\nLIS2HH12.pitch()\nRead the current pitch from the LIS2HH12. Returns a float in degrees in the range -90 to 90. Once the board tilts beyond this range the values will repeat. This is due to a lack of yaw measurement, making it not possible to know the exact orientation of the board.\nDigital Ambient Light Sensor (LTR-329ALS-01)\nPysense has a dual light sensor that provides outputs for external light levels in lux. See the datasheet for more information about the wavelengths of the two sensors.\nConstructors\nclass LTR329ALS01(pysense = None, sda = 'P22', scl = 'P21', gain = ALS_GAIN_1X, integration = ALS_INT_100, rate = ALS_RATE_500)\nCreates a LTR329ALS01 object, that will return values for light in lux. Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nLTR329ALS01.light()\nRead the light levels of both LTR329ALS01 sensors. Returns a tuple with two values for light levels in lux.\nArguments\nThe following arguments may be passed into the constructor.\n\ngain: ALS_GAIN_1X,ALS_GAIN_2X, ALS_GAIN_4X, ALS_GAIN_8X, ALS_GAIN_48X, ALS_GAIN_96X\nintegration: ALS_INT_50, ALS_INT_100, ALS_INT_150, ALS_INT_200, ALS_INT_250, ALS_INT_300, ALS_INT_350, ALS_INT_400\nrate: ALS_RATE_50, ALS_RATE_100, ALS_RATE_200, ALS_RATE_500, ALS_RATE_1000, ALS_RATE_2000\n\nHumidity and Temperature Sensor (SI7006A20)\nPysense has a Humidity and Temperature sensor that provides values of relative humidity and external temperature.\nConstructors\nclass SI7006A20(pysense = None, sda = 'P22', scl = 'P21')\nCreates a SI7006A20 object, that will return values for humidity (%) and temperature ('C). Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nSI7006A20.humidity()\nRead the relative humidity of the SI7006A20. Returns a float with the percentage relative humidity.\nSI7006A20.temperature()\nRead the external temperature of the SI7006A20. Returns a float with the temperature.\nBarometric Pressure Sensor with Altimeter (MPL3115A2)\nPysense has a Barometric Pressure sensor that provides readings for pressure, altitude as well as an additional temperature sensor.\nConstructors\nclass MPL3115A2(pysense = None, sda = 'P22', scl = 'P21', mode = PRESSURE)\nCreates a MPL3115A2 object, that will return values for pressure (Pa), altitude (m) and temperature ('C). Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nMPL3115A2.pressure()\nRead the atmospheric pressure of the MPL3115A2. Returns a float with the pressure in (Pa).\nMPL3115A2.altitude()\nRead the altitude of the MPL3115A2. Returns a float with the altitude in (m).\nMPL3115A2.temperature()\nRead the temperature of the MPL3115A2. Returns a float with the temperature in ('C).\nArguments\nThe following arguments may be passed into the constructor.\n\nmode: PRESSURE, ALTITUDE\n\nPlease note that more functionality is being added weekly to these libraries. If a required feature is not available, feel free to contribute with a pull request at the Libraries GitHub repository\n\n"},"pytrackpysense/apireference/pyscan.html":{"url":"pytrackpysense/apireference/pyscan.html","title":"Pyscan","keywords":"","body":"Pyscan\nThis chapter describes the various libraries which are designed for the Pyscan board. This includes details about the various methods and classes available for each of the Pyscan's sensors.\n3-Axis Accelerometer (LIS2HH12)\nPysense has a 3-Axis Accelerometer that provides outputs for acceleration as well as roll, pitch and yaw.\nConstructors\nclass LIS2HH12(pysense = None, sda = 'P22', scl = 'P21')\nCreates a LIS2HH12 object, that will return values for acceleration, roll, pitch and yaw. Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nLIS2HH12.acceleration()\nRead the acceleration from the LIS2HH12. Returns a tuple with the 3 values of acceleration (G).\nLIS2HH12.roll()\nRead the current roll from the LIS2HH12. Returns a float in degrees in the range -180 to 180.\nLIS2HH12.pitch()\nRead the current pitch from the LIS2HH12. Returns a float in degrees in the range -90 to 90. Once the board tilts beyond this range the values will repeat. This is due to a lack of yaw measurement, making it not possible to know the exact orientation of the board.\nDigital Ambient Light Sensor (LTR-329ALS-01)\nPysense has a dual light sensor that provides outputs for external light levels in lux. See the datasheet for more information about the wavelengths of the two sensors.\nConstructors\nclass LTR329ALS01(pysense = None, sda = 'P22', scl = 'P21', gain = ALS_GAIN_1X, integration = ALS_INT_100, rate = ALS_RATE_500)\nCreates a LTR329ALS01 object, that will return values for light in lux. Constructor must be passed a Pysense or I2C object to successfully construct.\nMethods\nLTR329ALS01.light()\nRead the light levels of both LTR329ALS01 sensors. Returns a tuple with two values for light levels in lux.\nArguments\nThe following arguments may be passed into the constructor.\n\ngain: ALS_GAIN_1X,ALS_GAIN_2X, ALS_GAIN_4X, ALS_GAIN_8X, ALS_GAIN_48X, ALS_GAIN_96X\nintegration: ALS_INT_50, ALS_INT_100, ALS_INT_150, ALS_INT_200, ALS_INT_250, ALS_INT_300, ALS_INT_350, ALS_INT_400\nrate: ALS_RATE_50, ALS_RATE_100, ALS_RATE_200, ALS_RATE_500, ALS_RATE_1000, ALS_RATE_2000\n\nPyscan NFC library (MFRC6300)\nConstructors\nclass MFRC630(pyscan=None, sda='P22', scl='P21', timeout=None, debug=False)\nCreates a MFRC630 object. Constructor must be passed a Pyscan or I2C object to successfully construct.\nMethods\nMFRC630.mfrc630_cmd_init()\nInitialise the MFRC630 with some settings\nMFRC630.mfrc630_cmd_reset()\nReset the device. Stops the currently active command and resets device.\nMFRC630.mfrc630_cmd_idle()\nSet the device into idle mode. Stops the currently active command and return to idle mode.\nMFRC630.mfrc630_cmd_load_key(key)\nLoads the provided key into the key buffer.\n\nkey Array which holds the MIFARE key, it is always 6 bytes long\n\nMFRC630.mfrc630_MF_read_block(block_address, dest)\nReads a block of memory from an authenticated card. Try to read a block of memory from the card with the appropriate timeouts and error checking.\n\nblock_address The block to read\ndest The array in which to write the 16 bytes read from the card\n\nReturns 0 for failure, otherwise the number of bytes received.\nMFRC630.mfrc630_MF_auth(uid, key_type, block)\nPerform a MIFARE authentication procedure. This function is a higher-level wrapper around the MF authenticate command. The result of the authentication is checked to identify whether it appears to have succeeded. The key must be loaded into the key buffer with MFRC630.mfrc630_cmd_load_key(key).\nOnce authenticated, the authentication MUST be stopped manually by calling the mfrc630_MF_deauth() function or otherwise disabling the Crypto1 ON bit in the status register.\n\nkey_type The MIFARE key A or B (MFRC630_MF_AUTH_KEY_A or MFRC630_MF_AUTH_KEY_B) to use\nblock The block to authenticate\nuid The authentication procedure required the first four bytes of the card's UID to authenticate\n\nReturns 0 in case of failure, nonzero in case of success.\nMFRC630.mfrc630_MF_deauth()\nDisables MIFARE authentication. Disable the Crypto1 bit from the status register to disable encryption.\nMFRC630.mfrc630_iso14443a_WUPA_REQA(instruction)\nSend WUPA and REQA. Returns the response byte, the answer to request A byte (ATQA), or 0 in case of no answer.\n\ninstruction: MFRC630_ISO14443_CMD_WUPA, MFRC630_ISO14443_CMD_REQA\n\nMFRC630.mfrc630_iso14443a_select(uid)\nPerforms the SELECT procedure to discover a card's UID. This performs the SELECT procedure as explained in ISO14443A, this determines the UID of the card, if multiple cards are present, a collision will occur, which is handled according to the norm.\n\nuid: The UID of the card will be stored into this array.\n\nReturns the length of the UID in bytes (4, 7, 10), or 0 in case of failure.\nMFRC630.print_debug(msg)\nPrints debug statements if DEBUG is enabled.\nMFRC630.format_block(block, length)\nPrints block with length.\nMFRC630.mfrc630_format_block(data, len)\nConverts data to hexadecimal format.\n\ndata The array to be formatted\nlen The number of bytes to format\n\nMFRC630.mfrc630_print_block(data, len)\nPrints the bytes in data array in hexadecimal format, separated by spaces using the mfrc630_format_block method.\n\ndata The array to be printed\nlen The number of bytes to print\n\nPlease note that more functionality is being added weekly to these libraries. If a required feature is not available, feel free to contribute with a pull request at the Libraries GitHub repository\n\n"},"pytrackpysense/apireference/sleep.html":{"url":"pytrackpysense/apireference/sleep.html","title":"Sleep","keywords":"","body":"Sleep\nThis chapter describes the various methods for sleep and wakeup which are embedded in Pytrack and Pysense libraries. Both Pytrack and Pysense have the same methods, although the appropriate class, either pytrack or pysense, has to be instantiated.\nQuick Usage Example\nThe following example is also available at Sleep Wakeup Example Libraries GitHub repository\n#from pytrack import Pytrack\nfrom pysense import Pysense\nfrom LIS2HH12 import LIS2HH12\nimport time\n\n#py = Pytrack()\npy = Pysense()\n\n# display the reset reason code and the sleep remaining in seconds\n# possible values of wakeup reason are:\n# WAKE_REASON_ACCELEROMETER = 1\n# WAKE_REASON_PUSH_BUTTON = 2\n# WAKE_REASON_TIMER = 4\n# WAKE_REASON_INT_PIN = 8\n\nprint(\"Wakeup reason: \" + str(py.get_wake_reason()))\nprint(\"Approximate sleep remaining: \" + str(py.get_sleep_remaining()) + \" sec\")\ntime.sleep(0.5)\n\n# enable wakeup source from INT pin\npy.setup_int_pin_wake_up(False)\n\nacc = LIS2HH12()\n\n# enable activity and also inactivity interrupts, using the default callback handler\npy.setup_int_wake_up(True, True)\n\n# set the acceleration threshold to 2000mG (2G) and the min duration to 200ms\nacc.enable_activity_interrupt(2000, 200)\n\n# go to sleep for 5 minutes maximum if no accelerometer interrupt happens\npy.setup_sleep(300)\npy.go_to_sleep()\n\nMethods\npytrack.get_sleep_remaining()\nIn the event of a sleep session that was awoken by an asynchronous event (Accelerometer, INT pin or Reset button) the approximate sleep remaining interval (expressed in seconds) can be found out. The user has to manually use setup_sleep() to configure the next sleep interval.\npytrack.get_wake_reason()\nReturns the last wakeup reason. Possible values are:\n# WAKE_REASON_ACCELEROMETER = 1 # Accelerometer activity/inactivity detection\n# WAKE_REASON_PUSH_BUTTON = 2 # Pytrack/Pysense reset buttom\n# WAKE_REASON_TIMER = 4 # Normal timeout of the sleep interval\n# WAKE_REASON_INT_PIN = 8 # INT pin\n\nNote: the WAKE_REASON_INT_PIN can be used if the PIC_RC1 pin (pin#6 on External IO Header) is toggled.\nAs in the above example, this method should be called at the beginning of the script, to find out the reset (wakeup) reason.\npytrack.go_to_sleep([gps=True])\nPuts the board in sleep mode, for the duration, which has to be set previously with pytrack.setup_sleep(timout_sec). The optional boolean parameter sets the GPS state during sleep.\nMicroPython code, which is after this function, is not executed, as wakeup will restart MicroPython.\npytrack.setup_int_wake_up(rising, falling])\nEnables as wakeup source, the accelerometer INT pin (PIC - RA5). The boolean parameters will indicate rising edge (activity detection) and/or falling edge (inactivity detection) is configured.\nThe accelerometer (class LIS2HH12) has to be also configured for a certain acceleration threshold and duration. Code snippet:\nfrom pytrack import Pytrack\nfrom LIS2HH12 import LIS2HH12\n\npy = Pytrack()\nacc = LIS2HH12()\n\n# enable activity and also inactivity interrupts, using the default callback handler\npy.setup_int_wake_up(True, True)\n\n# set the acceleration threshold to 2000mG (2G) and the min duration to 200ms\nacc.enable_activity_interrupt(2000, 200)\n\npytrack.setup_int_pin_wake_up([rising_edge = True])\nEnables as wakeup source, the INT pic (PIC - RC1, pin#6 on External IO Header). Either rising or falling edge has to be set, by default it's rising edge.\npytrack.setup_sleep(time_seconds)\nSets the sleep interval, specified in seconds. The actual sleep will be started by calling go_to_sleep() method.\nPlease note that more functionality is being added weekly to these libraries. If a required feature is not available, feel free to contribute with a pull request at the Libraries GitHub repository\n\n"},"tutorials/introduction.html":{"url":"tutorials/introduction.html","title":"Introduction","keywords":"","body":"Introduction\n\nTutorials and Examples\nThis section contains tutorials and examples for use with Pycom modules and Expansion boards.\nGeneral Pycom tutorials contains tutorials that may be run on any Pycom device, such as connecting to a WiFi network, Bluetooth, controlling I/O pins etc. Later sections are specific to the LoPy and SiPy devices such as setting up a LoRa node or connecting to the Sigfox network. The final sections are related to examples using the Pytrack and Pysense.\nBefore starting, ensure that any Pycom devices are running the latest firmware; for instructions see Firmware Updates.\nThe source code for these tutorials, along with the required libraries can be found in in the pycom-libraries repository.\n"},"tutorials/all/":{"url":"tutorials/all/","title":"All Pycom Device Examples","keywords":"","body":"All Pycom Device Examples\nThis section contains generic examples that will work across all Pycom devices and Expansion Boards.\n"},"tutorials/all/repl.html":{"url":"tutorials/all/repl.html","title":"REPL","keywords":"","body":"REPL\nUsing the Pymakr Plugin, open and connect a device or use serial terminal (PuTTY, screen, picocom, etc). Upon connecting, there should be a blank screen with a flashing cursor. Press Enter and a MicroPython prompt should appear, i.e. >>>. Let's make sure it is working with the obligatory test:\n>>> print(\"Hello LoPy!\")\nHello LoPy!\n\nIn the example above, the >>> characters should not be typed. They are there to indicate that the text should be placed after the prompt. Once the text has been entered print(\"Hello LoPy!\") and pressed Enter, the output should appear on screen, identical to the example above.\nBasic Python commands can be tested out in a similar fashion.\nIf this is not working, try either a hard reset or a soft reset; see below.\nHere are some other example, utilising the device's hardware features:\n>>> from machine import Pin\n>>> led = Pin('G16', mode=Pin.OUT, value=1)\n>>> led(0)\n>>> led(1)\n>>> led.toggle()\n>>> 1 + 2\n3\n>>> 5 / 2\n2.5\n>>> 20 * 'py'\n'pypypypypypypypypypypypypypypypypypypypy'\n\nResetting the Device\nIf something goes wrong, the device can be reset with two methods. The first is to press CTRL-D at the MicroPython prompt, which will perform a soft reset. A message, as following, will appear:\n>>>\nPYB: soft reboot\nMicroPython v1.4.6-146-g1d8b5e5 on 2016-10-21; LoPy with ESP32\nType \"help()\" for more information.\n>>>\n\nIf that still isn't working a hard reset can be performed (power-off/on) by pressing the RST switch (the small black button next to the RGB LED). Using telnet, this will end the session, disconnecting the program that was used to connect to the Pycom Device.\n"},"tutorials/all/wlan.html":{"url":"tutorials/all/wlan.html","title":"WLAN","keywords":"","body":"WLAN\nThe WLAN is a system feature of all Pycom devices, therefore it is enabled by default.\nIn order to retrieve the current WLAN instance, run:\n>>> from network import WLAN\n>>> wlan = WLAN() # we call the constructor without params\n\nThe current mode (WLAN.AP after power up) may be checked by running:\n>>> wlan.mode()\n\nWhen changing the WLAN mode, if following the instructions below, the WLAN connection to the Pycom device will be broken. This means commands will not run interactively over WiFi.\nThere are two ways around this:\n\nPut this setup code into the boot.py file of the Pycom device so that it gets executed automatically after reset.\nDuplicate the REPL on UART. This way commands can be run via Serial USB.\n\n\nConnecting to a Router\nThe WLAN network class always boots in WLAN.AP mode; to connect it to an existing network, the WiFi class must be configured as a station:\nfrom network import WLAN\nwlan = WLAN(mode=WLAN.STA)\n\nNow the device may proceed to scan for networks:\nnets = wlan.scan()\nfor net in nets:\n if net.ssid == 'mywifi':\n print('Network found!')\n wlan.connect(net.ssid, auth=(net.sec, 'mywifikey'), timeout=5000)\n while not wlan.isconnected():\n machine.idle() # save power while waiting\n print('WLAN connection succeeded!')\n break\n\nAssigning a Static IP Address at Boot Up\nIf the users wants their device to connect to a home router upon boot up, using with a fixed IP address, use the following script as /flash/boot.py:\nimport machine\nfrom network import WLAN\nwlan = WLAN() # get current object, without changing the mode\n\nif machine.reset_cause() != machine.SOFT_RESET:\n wlan.init(mode=WLAN.STA)\n # configuration below MUST match your home router settings!!\n wlan.ifconfig(config=('192.168.178.107', '255.255.255.0', '192.168.178.1', '8.8.8.8'))\n\nif not wlan.isconnected():\n # change the line below to match your network ssid, security and password\n wlan.connect('mywifi', auth=(WLAN.WPA2, 'mywifikey'), timeout=5000)\n while not wlan.isconnected():\n machine.idle() # save power while waiting\n\nNotice how we check for the reset cause and the connection status, this is crucial in order to be able to soft reset the LoPy during a telnet session without breaking the connection.\n\nMultiple Networks using a Static IP Address\nThe following script holds a list with nets and an optional list of wlan_config to set a fixed IP\nimport os\nimport machine\n\nuart = machine.UART(0, 115200)\nos.dupterm(uart)\n\nknown_nets = {\n '': {'pwd': ''},\n '': {'pwd': '', 'wlan_config': ('10.0.0.114', '255.255.0.0', '10.0.0.1', '10.0.0.1')}, # (ip, subnet_mask, gateway, DNS_server)\n}\n\nif machine.reset_cause() != machine.SOFT_RESET:\n from network import WLAN\n wl = WLAN()\n wl.mode(WLAN.STA)\n original_ssid = wl.ssid()\n original_auth = wl.auth()\n\n print(\"Scanning for known wifi nets\")\n available_nets = wl.scan()\n nets = frozenset([e.ssid for e in available_nets])\n\n known_nets_names = frozenset([key for key in known_nets])\n net_to_use = list(nets & known_nets_names)\n try:\n net_to_use = net_to_use[0]\n net_properties = known_nets[net_to_use]\n pwd = net_properties['pwd']\n sec = [e.sec for e in available_nets if e.ssid == net_to_use][0]\n if 'wlan_config' in net_properties:\n wl.ifconfig(config=net_properties['wlan_config'])\n wl.connect(net_to_use, (sec, pwd), timeout=10000)\n while not wl.isconnected():\n machine.idle() # save power while waiting\n print(\"Connected to \"+net_to_use+\" with IP address:\" + wl.ifconfig()[0])\n\n except Exception as e:\n print(\"Failed to connect to any known network, going into AP mode\")\n wl.init(mode=WLAN.AP, ssid=original_ssid, auth=original_auth, channel=6, antenna=WLAN.INT_ANT)\n\nConnecting to a WPA2-Enterprise network\nConnecting with EAP-TLS:\nBefore connecting, obtain and copy the public and private keys to the device, e.g. under location /flash/cert. If it is required to validate the server's public key, an appropriate CA certificate (chain) must also be provided.\nfrom network import WLAN\n\nwlan = WLAN(mode=WLAN.STA)\nwlan.connect(ssid='mywifi', auth=(WLAN.WPA2_ENT,), identity='myidentity', ca_certs='/flash/cert/ca.pem', keyfile='/flash/cert/client.key', certfile='/flash/cert/client.crt')\n\nConnecting with EAP-PEAP or EAP-TTLS:\nIn case of EAP-PEAP (or EAP-TTLS), the client key and certificate are not necessary, only a username and password pair. If it is required to validate the server's public key, an appropriate CA certificate (chain) must also be provided.\nfrom network import WLAN\n\nwlan = WLAN(mode=WLAN.STA)\nwlan.connect(ssid='mywifi', auth=(WLAN.WPA2_ENT, 'username', 'password'), identity='myidentity', ca_certs='/flash/cert/ca.pem')\n\n"},"tutorials/all/ble.html":{"url":"tutorials/all/ble.html","title":"Bluetooth","keywords":"","body":"Bluetooth\nAt present, basic BLE functionality is available. More features will be implemented in the near future, such as pairing. This page will be updated in line with these features.\nFull info on bluetooth can be found within Bluetooth page of the Firmware API Reference.\nScan for BLE Devices\nScan for all of the advertising devices within range of the scanning device.\nbluetooth.start_scan(10) # starts scanning and stop after 10 seconds\nbluetooth.start_scan(-1) # starts scanning indefinitely until bluetooth.stop_scan() is called\n\nRaw Data from a BLE Device\nA quick usage example that scans and prints the raw data from advertisements.\nfrom network import Bluetooth\n\nbluetooth = Bluetooth()\nbluetooth.start_scan(-1) # start scanning with no timeout\n\nwhile True:\n print(bluetooth.get_adv())\n\nConnect to a BLE Device\nConnecting to a device that is sending advertisements.\nfrom network import Bluetooth\nimport ubinascii\nbluetooth = Bluetooth()\n\n# scan until we can connect to any BLE device around\nbluetooth.start_scan(-1)\nadv = None\nwhile True:\n adv = bluetooth.get_adv()\n if adv:\n try:\n bluetooth.connect(adv.mac)\n except:\n # start scanning again\n bluetooth.start_scan(-1)\n continue\n break\nprint(\"Connected to device with addr = {}\".format(ubinascii.hexlify(adv.mac)))\n\nConnect to a BLE Device and Retrieve Data\nConnecting to a device named 'Heart Rate' and receiving data from it's services.\nfrom network import Bluetooth\nimport time\nbt = Bluetooth()\nbt.start_scan(-1)\n\nwhile True:\n adv = bt.get_adv()\n if adv and bt.resolve_adv_data(adv.data, Bluetooth.ADV_NAME_CMPL) == 'Heart Rate':\n try:\n conn = bt.connect(adv.mac)\n services = conn.services()\n for service in services:\n time.sleep(0.050)\n if type(service.uuid()) == bytes:\n print('Reading chars from service = {}'.format(service.uuid()))\n else:\n print('Reading chars from service = %x' % service.uuid())\n chars = service.characteristics()\n for char in chars:\n if (char.properties() & Bluetooth.PROP_READ):\n print('char {} value = {}'.format(char.uuid(), char.read()))\n conn.disconnect()\n break\n except:\n pass\n else:\n time.sleep(0.050)\n\nRetrieve the Name & Manufacturer from a BLE Device\nUsing resolve_adv_data() to attempt to retrieve the name and manufacturer data from the advertiser.\nimport ubinascii\nfrom network import Bluetooth\nbluetooth = Bluetooth()\n\nbluetooth.start_scan(20)\nwhile bluetooth.isscanning():\n adv = bluetooth.get_adv()\n if adv:\n # try to get the complete name\n print(bluetooth.resolve_adv_data(adv.data, Bluetooth.ADV_NAME_CMPL))\n\n mfg_data = bluetooth.resolve_adv_data(adv.data, Bluetooth.ADV_MANUFACTURER_DATA)\n\n if mfg_data:\n # try to get the manufacturer data (Apple's iBeacon data is sent here)\n print(ubinascii.hexlify(mfg_data))\n\n"},"tutorials/all/https.html":{"url":"tutorials/all/https.html","title":"HTTPS","keywords":"","body":"HTTPS\nBasic connection using ssl.wrap_socket().\nimport socket\nimport ssl\n\ns = socket.socket()\nss = ssl.wrap_socket(s)\nss.connect(socket.getaddrinfo('www.google.com', 443)[0][-1])\n\nBelow is an example using certificates with the blynk cloud.\nCertificate was downloaded from the blynk examples folder and placed in /flash/cert/ on the device.\nimport socket\nimport ssl\n\ns = socket.socket()\nss = ssl.wrap_socket(s, cert_reqs=ssl.CERT_REQUIRED, ca_certs='/flash/cert/ca.pem')\nss.connect(socket.getaddrinfo('cloud.blynk.cc', 8441)[0][-1])\n\nFor more info, check the ssl module in the API reference.\n"},"tutorials/all/mqtt.html":{"url":"tutorials/all/mqtt.html","title":"MQTT","keywords":"","body":"MQTT\nMQTT is a lightweight messaging protocol that is ideal for sending small packets of data to and from IoT devices via WiFi.\nThe broker used in this example is the IO Adafruit platform, which is free and allows for tinkering with MQTT.\nVisit IO Adafruit and create an account. You'll need to get hold of an API Key as well as your credentials. Visit this guide for more information about MQTT and how to use it with Adafruit's Broker.\nThis example will send a message to a topic on the Adafruit MQTT broker and then also subscribe to the same topic, in order to show how to use the subscribe functionality.\nfrom mqtt import MQTTClient\nfrom network import WLAN\nimport machine\nimport time\n\ndef sub_cb(topic, msg):\n print(msg)\n\nwlan = WLAN(mode=WLAN.STA)\nwlan.connect(\"yourwifinetwork\", auth=(WLAN.WPA2, \"wifipassword\"), timeout=5000)\n\nwhile not wlan.isconnected(): \n machine.idle()\nprint(\"Connected to WiFi\\n\")\n\nclient = MQTTClient(\"device_id\", \"io.adafruit.com\",user=\"your_username\", password=\"your_api_key\", port=1883)\n\nclient.set_callback(sub_cb)\nclient.connect()\nclient.subscribe(topic=\"youraccount/feeds/lights\")\n\nwhile True:\n print(\"Sending ON\")\n client.publish(topic=\"youraccount/feeds/lights\", msg=\"ON\")\n time.sleep(1)\n print(\"Sending OFF\")\n client.publish(topic=\"youraccount/feeds/lights\", msg=\"OFF\")\n client.check_msg()\n\n time.sleep(1)\n\n"},"tutorials/all/aws.html":{"url":"tutorials/all/aws.html","title":"AWS","keywords":"","body":"AWS\nThe AWS IoT platform enables devices to connect to the Amazon cloud and lets applications in the cloud interact with Internet-connected things. Common IoT applications either collect and process telemetry from devices or enable users to control a device remotely. Things report their state by publishing messages, in JSON format, on MQTT topics.\nFor more information see this PDF File.\nGetting Started with AWS IoT\nCreating the message broker (Amazon website):\n\nSign in to the AWS Management Console\nNavigate to the IoT Console by clicking on the AWS IoT link\nIn the left navigation pane, choose Register/Manage\nClick on the create button, give your device a name and press create\nClick on the device that has been created\nOn the Details page, in the left navigation pane, choose Security\nOn the Certificates page, choose Create certificate\nDownload all the certificates, then press the Activate and the Attach a Policy buttons. See image\nClick on the Create New Policy button\nOn the Create Policy page, choose a policy name and the actions to authorise.\nGo to the certificates page, click on the three dots of your certificate and attach the policy to the certificate as shown in the diagram\n\nSetting up the device (Pycom device):\n\nDownload the latest sample code from the Pycom GitHub Repository.\nConnect to the device via FTP and put the root CA certificate, the client certificate (*.pem.crt) and the private key (*.private.pem.key) in the /flash/cert folder.\nUpdate the config file with your WiFi settings, the AWS Host and the certificate paths.\nPut the config.py and the main.py in the device flash\n\nConfiguration (config.py):\nThis file contains the WiFi, certificate paths and application specific settings that need to be updated by the user.\n# WiFi configuration\nWIFI_SSID = 'my_wifi_ssid'\nWIFI_PASS = 'my_wifi_password'\n\n# AWS general configuration\nAWS_PORT = 8883\nAWS_HOST = 'aws_host_url'\nAWS_ROOT_CA = '/flash/cert/aws_root.ca'\nAWS_CLIENT_CERT = '/flash/cert/aws_client.cert'\nAWS_PRIVATE_KEY = '/flash/cert/aws_private.key'\n\n################## Subscribe / Publish client #################\nCLIENT_ID = 'PycomPublishClient'\nTOPIC = 'PublishTopic'\nOFFLINE_QUEUE_SIZE = -1\nDRAINING_FREQ = 2\nCONN_DISCONN_TIMEOUT = 10\nMQTT_OPER_TIMEOUT = 5\nLAST_WILL_TOPIC = 'PublishTopic'\nLAST_WILL_MSG = 'To All: Last will message'\n\n####################### Shadow updater ########################\n#THING_NAME = \"my thing name\"\n#CLIENT_ID = \"ShadowUpdater\"\n#CONN_DISCONN_TIMEOUT = 10\n#MQTT_OPER_TIMEOUT = 5\n\n####################### Delta Listener ########################\n#THING_NAME = \"my thing name\"\n#CLIENT_ID = \"DeltaListener\"\n#CONN_DISCONN_TIMEOUT = 10\n#MQTT_OPER_TIMEOUT = 5\n\n####################### Shadow Echo ########################\n#THING_NAME = \"my thing name\"\n#CLIENT_ID = \"ShadowEcho\"\n#CONN_DISCONN_TIMEOUT = 10\n#MQTT_OPER_TIMEOUT = 5\n\nSubscibe / Publish (main.py)\nTo subscribe to a topic:\n\nGo to the AWS Iot page, click on manage and choose your device\nFrom the left hand side, choose Activity and then click MQTT client.\nChoose the topic name you entered in the configuration file.\nMessages should be published as shown in the diagram\n\n# user specified callback function\ndef customCallback(client, userdata, message):\n print(\"Received a new message: \")\n print(message.payload)\n print(\"from topic: \")\n print(message.topic)\n print(\"--------------\\n\\n\")\n\n# configure the MQTT client\npycomAwsMQTTClient = AWSIoTMQTTClient(config.CLIENT_ID)\npycomAwsMQTTClient.configureEndpoint(config.AWS_HOST, config.AWS_PORT)\npycomAwsMQTTClient.configureCredentials(config.AWS_ROOT_CA, config.AWS_PRIVATE_KEY, config.AWS_CLIENT_CERT)\n\npycomAwsMQTTClient.configureOfflinePublishQueueing(config.OFFLINE_QUEUE_SIZE)\npycomAwsMQTTClient.configureDrainingFrequency(config.DRAINING_FREQ)\npycomAwsMQTTClient.configureConnectDisconnectTimeout(config.CONN_DISCONN_TIMEOUT)\npycomAwsMQTTClient.configureMQTTOperationTimeout(config.MQTT_OPER_TIMEOUT)\npycomAwsMQTTClient.configureLastWill(config.LAST_WILL_TOPIC, config.LAST_WILL_MSG, 1)\n\n#Connect to MQTT Host\nif pycomAwsMQTTClient.connect():\n print('AWS connection succeeded')\n\n# Subscribe to topic\npycomAwsMQTTClient.subscribe(config.TOPIC, 1, customCallback)\ntime.sleep(2)\n\n# Send message to host\nloopCount = 0\nwhile loopCount \nShadow updater (main.py)\n# user specified callback functions\ndef customShadowCallback_Update(payload, responseStatus, token):\n if responseStatus == \"timeout\":\n print(\"Update request \" + token + \" time out!\")\n if responseStatus == \"accepted\":\n payloadDict = json.loads(payload)\n print(\"Update request with token: \" + token + \" accepted!\")\n print(\"property: \" + str(payloadDict[\"state\"][\"desired\"][\"property\"]))\n if responseStatus == \"rejected\":\n print(\"Update request \" + token + \" rejected!\")\n\ndef customShadowCallback_Delete(payload, responseStatus, token):\n if responseStatus == \"timeout\":\n print(\"Delete request \" + token + \" time out!\")\n if responseStatus == \"accepted\":\n print(\"Delete request with token: \" + token + \" accepted!\")\n if responseStatus == \"rejected\":\n print(\"Delete request \" + token + \" rejected!\")\n\n# configure the MQTT client\npycomAwsMQTTShadowClient = AWSIoTMQTTShadowClient(config.CLIENT_ID)\npycomAwsMQTTShadowClient.configureEndpoint(config.AWS_HOST, config.AWS_PORT)\npycomAwsMQTTShadowClient.configureCredentials(config.AWS_ROOT_CA, config.AWS_PRIVATE_KEY, config.AWS_CLIENT_CERT)\n\npycomAwsMQTTShadowClient.configureConnectDisconnectTimeout(config.CONN_DISCONN_TIMEOUT)\npycomAwsMQTTShadowClient.configureMQTTOperationTimeout(config.MQTT_OPER_TIMEOUT)\n\n# Connect to MQTT Host\nif pycomAwsMQTTShadowClient.connect():\n print('AWS connection succeeded')\n\ndeviceShadowHandler = pycomAwsMQTTShadowClient.createShadowHandlerWithName(config.THING_NAME, True)\n\n# Delete shadow JSON doc\ndeviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)\n\n# Update shadow in a loop\nloopCount = 0\nwhile True:\n JSONPayload = '{\"state\":{\"desired\":{\"property\":' + str(loopCount) + '}}}'\n deviceShadowHandler.shadowUpdate(JSONPayload, customShadowCallback_Update, 5)\n loopCount += 1\n time.sleep(5)\n\nDelta Listener (main.py)\n# Custom Shadow callback\ndef customShadowCallback_Delta(payload, responseStatus, token):\n payloadDict = json.loads(payload)\n print(\"property: \" + str(payloadDict[\"state\"][\"property\"]))\n print(\"version: \" + str(payloadDict[\"version\"]))\n\n # configure the MQTT client\npycomAwsMQTTShadowClient = AWSIoTMQTTShadowClient(config.CLIENT_ID)\npycomAwsMQTTShadowClient.configureEndpoint(config.AWS_HOST, config.AWS_PORT)\npycomAwsMQTTShadowClient.configureCredentials(config.AWS_ROOT_CA, config.AWS_PRIVATE_KEY, config.AWS_CLIENT_CERT)\n\npycomAwsMQTTShadowClient.configureConnectDisconnectTimeout(config.CONN_DISCONN_TIMEOUT)\npycomAwsMQTTShadowClient.configureMQTTOperationTimeout(config.MQTT_OPER_TIMEOUT)\n\n# Connect to MQTT Host\nif pycomAwsMQTTShadowClient.connect():\n print('AWS connection succeeded')\n\ndeviceShadowHandler = pycomAwsMQTTShadowClient.createShadowHandlerWithName(config.THING_NAME, True)\n\n# Listen on deltas\ndeviceShadowHandler.shadowRegisterDeltaCallback(customShadowCallback_Delta)\n\n# Loop forever\nwhile True:\n time.sleep(1)\n\n"},"tutorials/all/adc.html":{"url":"tutorials/all/adc.html","title":"ADC","keywords":"","body":"ADC\nThis example is a simple ADC sample. For more information please see ADC.\nfrom machine import ADC\nadc = ADC(0)\nadc_c = adc.channel(pin='P13')\nadc_c()\nadc_c.value()\n\nCalibration\nCurrently the ESP32's ADC is not calibrated from the factory. This means it must be calibrated each time you wish to use it. To do this you must firstly measure the internal voltage reference. The following code will connect the 1.1v reference to P22\nfrom machine import ADC\nadc = ADC()\n\n# Output Vref of P22\nadc.vref_to_pin('P22')\n\nNow that the voltage reference is externally accessible you should measure it with the most accurate voltmeter you have access to. Note down the reading in millivolts, e.g. 1120. To disconnect the 1.1v reference from P22 please reset your module. You can now calibrate the ADC by telling it the true value of the internal reference. You should then check your calibration by connecting the ADC to a known voltage source.\n# Set calibration - see note above\nadc.vref(1100)\n\n# Check calibration by reading a known voltage\nadc_c = adc.channel(pin='P16', attn=ADC.ATTN_11DB)\nprint(adc_c.voltage())\n\n"},"tutorials/all/i2c.html":{"url":"tutorials/all/i2c.html","title":"I2C","keywords":"","body":"I2C\nThe following example receives data from a light sensor using I2C. Sensor used is the BH1750FVI Digital Light Sensor.\nimport time\nfrom machine import I2C\nimport bh1750fvi\n\ni2c = I2C(0, I2C.MASTER, baudrate=100000)\nlight_sensor = bh1750fvi.BH1750FVI(i2c, addr=i2c.scan()[0])\n\nwhile(True):\n data = light_sensor.read()\n print(data)\n time.sleep(1)\n\nDrivers for the BH1750FVI\nPlace this sample code into a file named bh1750fvi.py. This can then be imported as a library.\n# Simple driver for the BH1750FVI digital light sensor\n\nclass BH1750FVI:\n MEASUREMENT_TIME = const(120)\n\n def __init__(self, i2c, addr=0x23, period=150):\n self.i2c = i2c\n self.period = period\n self.addr = addr\n self.time = 0\n self.value = 0\n self.i2c.writeto(addr, bytes([0x10])) # start continuos 1 Lux readings every 120ms\n\n def read(self):\n self.time += self.period\n if self.time >= MEASUREMENT_TIME:\n self.time = 0\n data = self.i2c.readfrom(self.addr, 2)\n self.value = (((data[0] \nLight sensor and LoRa\nThis is the same code, with added LoRa connectivity, sending the lux value from the light sensor to another LoRa enabled device.\nimport socket\nimport time\nimport pycom\nimport struct\nfrom network import LoRa\nfrom machine import I2C\nimport bh1750fvi\n\nLORA_PKG_FORMAT = \"!BH\"\nLORA_CONFIRM_FORMAT = \"!BB\"\n\nDEVICE_ID = 1\n\npycom.heartbeat(False)\n\nlora = LoRa(mode=LoRa.LORA, tx_iq=True, region=LoRa.EU868)\nlora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\nlora_sock.setblocking(False)\n\ni2c = I2C(0, I2C.MASTER, baudrate=100000)\nlight_sensor = bh1750fvi.BH1750FVI(i2c, addr=i2c.scan()[0])\n\nwhile(True):\n msg = struct.pack(LORA_PKG_FORMAT, DEVICE_ID, light_sensor.read())\n lora_sock.send(msg)\n\n pycom.rgbled(0x150000)\n\n wait = 5\n while (wait > 0):\n wait = wait - 0.1\n time.sleep(0.1)\n recv_data = lora_sock.recv(64)\n\n if (len (recv_data) >= 2):\n status, device_id = struct.unpack(LORA_CONFIRM_FORMAT, recv_data)\n\n if (device_id == DEVICE_ID and status == 200):\n pycom.rgbled(0x001500)\n wait = 0\n\n time.sleep(1)\n\n"},"tutorials/all/owd.html":{"url":"tutorials/all/owd.html","title":"Onewire Driver","keywords":"","body":"Onewire Driver\nThis tutorial explains how to connect and read data from a DS18x20 temperature sensor. The onewire library is also available at the pycom-libraries GitHub Repository.\nBasic usage\nimport time\nfrom machine import Pin\nfrom onewire import DS18X20\nfrom onewire import OneWire\n\n# DS18B20 data line connected to pin P10\now = OneWire(Pin('P10'))\ntemp = DS18X20(ow)\n\nwhile True:\n print(temp.read_temp_async())\n time.sleep(1)\n temp.start_conversion()\n time.sleep(1)\n\nLibrary\n#!/usr/bin/env python3\n\n\"\"\"\nOneWire library for MicroPython\n\"\"\"\n\nimport time\nimport machine\n\nclass OneWire:\n CMD_SEARCHROM = const(0xf0)\n CMD_READROM = const(0x33)\n CMD_MATCHROM = const(0x55)\n CMD_SKIPROM = const(0xcc)\n\n def __init__(self, pin):\n self.pin = pin\n self.pin.init(pin.OPEN_DRAIN, pin.PULL_UP)\n\n def reset(self):\n \"\"\"\n Perform the onewire reset function.\n Returns True if a device asserted a presence pulse, False otherwise.\n \"\"\"\n sleep_us = time.sleep_us\n disable_irq = machine.disable_irq\n enable_irq = machine.enable_irq\n pin = self.pin\n\n pin(0)\n sleep_us(480)\n i = disable_irq()\n pin(1)\n sleep_us(60)\n status = not pin()\n enable_irq(i)\n sleep_us(420)\n return status\n\n def read_bit(self):\n sleep_us = time.sleep_us\n enable_irq = machine.enable_irq\n pin = self.pin\n\n pin(1) # half of the devices don't match CRC without this line\n i = machine.disable_irq()\n pin(0)\n sleep_us(1)\n pin(1)\n sleep_us(1)\n value = pin()\n enable_irq(i)\n sleep_us(40)\n return value\n\n def read_byte(self):\n value = 0\n for i in range(8):\n value |= self.read_bit() >= 1\n\n def write_bytes(self, buf):\n for b in buf:\n self.write_byte(b)\n\n def select_rom(self, rom):\n \"\"\"\n Select a specific device to talk to. Pass in rom as a bytearray (8 bytes).\n \"\"\"\n self.reset()\n self.write_byte(CMD_MATCHROM)\n self.write_bytes(rom)\n\n def crc8(self, data):\n \"\"\"\n Compute CRC\n \"\"\"\n crc = 0\n for i in range(len(data)):\n byte = data[i]\n for b in range(8):\n fb_bit = (crc ^ byte) & 0x01\n if fb_bit == 0x01:\n crc = crc ^ 0x18\n crc = (crc >> 1) & 0x7f\n if fb_bit == 0x01:\n crc = crc | 0x80\n byte = byte >> 1\n return crc\n\n def scan(self):\n \"\"\"\n Return a list of ROMs for all attached devices.\n Each ROM is returned as a bytes object of 8 bytes.\n \"\"\"\n devices = []\n diff = 65\n rom = False\n for i in range(0xff):\n rom, diff = self._search_rom(rom, diff)\n if rom:\n devices += [rom]\n if diff == 0:\n break\n return devices\n\n def _search_rom(self, l_rom, diff):\n if not self.reset():\n return None, 0\n self.write_byte(CMD_SEARCHROM)\n if not l_rom:\n l_rom = bytearray(8)\n rom = bytearray(8)\n next_diff = 0\n i = 64\n for byte in range(8):\n r_b = 0\n for bit in range(8):\n b = self.read_bit()\n if self.read_bit():\n if b: # there are no devices or there is an error on the bus\n return None, 0\n else:\n if not b: # collision, two devices with different bit meaning\n if diff > i or ((l_rom[byte] & (1 > 1 | 0x80 # truncate bit 0 by shifting, fill high bit with 1.\n temp_read = -((~temp_read + 1) & 0xff) # now convert from two's complement\n else:\n temp_read = temp_lsb >> 1 # truncate bit 0 by shifting\n count_remain = data[6]\n count_per_c = data[7]\n temp = 100 * temp_read - 25 + (count_per_c - count_remain) // count_per_c\n return temp\n elif rom0 == 0x28:\n return (temp_msb \n"},"tutorials/all/threading.html":{"url":"tutorials/all/threading.html","title":"Threading","keywords":"","body":"Threading\nMicroPython supports spawning threads by the _thread module. The following example demonstrates the use of this module. A thread is simply defined as a function that can receive any number of parameters. Below 3 threads are started, each one perform a print at a different interval.\nimport _thread\nimport time\n\ndef th_func(delay, id):\n while True:\n time.sleep(delay)\n print('Running thread %d' % id)\n\nfor i in range(3):\n _thread.start_new_thread(th_func, (i + 1, i))\n\nUsing Locks:\nimport _thread\n\na_lock = _thread.allocate_lock()\n\nwith a_lock:\n print(\"a_lock is locked while this executes\")\n\n"},"tutorials/all/rgbled.html":{"url":"tutorials/all/rgbled.html","title":"RGB LED","keywords":"","body":"RGB LED\nBy default the heartbeat LED flashes in blue colour once every 4s to signal that the system is alive. This can be overridden through the pycom module.\nimport pycom\n\npycom.heartbeat(False)\npycom.rgbled(0xff00) # turn on the RGB LED in green colour\n\nThe heartbeat LED is also used to indicate that an error was detected.\nThe following piece of code uses the RGB LED to make a traffic light that runs for 10 cycles.\nimport pycom\nimport time\n\npycom.heartbeat(False)\nfor cycles in range(10): # stop after 10 cycles\n pycom.rgbled(0x007f00) # green\n time.sleep(5)\n pycom.rgbled(0x7f7f00) # yellow\n time.sleep(1.5)\n pycom.rgbled(0x7f0000) # red\n time.sleep(4)\n\nHere is the expected result:\n\n"},"tutorials/all/timers.html":{"url":"tutorials/all/timers.html","title":"Timers","keywords":"","body":"Timers\nDetailed information about this class can be found in Timer.\nChronometer\nThe Chronometer can be used to measure how much time has elapsed in a block of code. The following example uses a simple stopwatch.\nfrom machine import Timer\nimport time\n\nchrono = Timer.Chrono()\n\nchrono.start()\ntime.sleep(1.25) # simulate the first lap took 1.25 seconds\nlap = chrono.read() # read elapsed time without stopping\ntime.sleep(1.5)\nchrono.stop()\ntotal = chrono.read()\n\nprint()\nprint(\"\\nthe racer took %f seconds to finish the race\" % total)\nprint(\" %f seconds in the first lap\" % lap)\nprint(\" %f seconds in the last lap\" % (total - lap))\n\nAlarm\nThe Alarm can be used to get interrupts at a specific interval. The following code executes a callback every second for 10 seconds.\nfrom machine import Timer\n\nclass Clock:\n\n def __init__(self):\n self.seconds = 0\n self.__alarm = Timer.Alarm(self._seconds_handler, 1, periodic=True)\n\n def _seconds_handler(self, alarm):\n self.seconds += 1\n print(\"%02d seconds have passed\" % self.seconds)\n if self.seconds == 10:\n alarm.callback(None) # stop counting after 10 seconds\n\nclock = Clock()\n\nThere are no restrictions to what can be done in an interrupt. For example, it is possible to even do network requests with an interrupt. However, it is important to keep in mind that interrupts are handled sequentially, so it's good practice to keep them short. More information can be found in Interrupt Handling.\n\n"},"tutorials/all/pir.html":{"url":"tutorials/all/pir.html","title":"PIR Sensor","keywords":"","body":"PIR Sensor\nThis code reads PIR sensor triggers from this simple PIR sensor and sends an HTTP request for every trigger, in this case to a Domoticz installation. When motion is constantly detected, this PIR sensor keeps the pin high, in which case this code will keep sending HTTP requests every 10 seconds (configurable with the hold_time variable).\nMain (main.py)\nimport time\nfrom network import WLAN\nfrom machine import Pin\nfrom domoticz import Domoticz\n\nwl = WLAN(WLAN.STA)\nd = Domoticz(\"\", 8080 ,\"\")\n\n#config\nhold_time_sec = 10\n\n#flags\nlast_trigger = -10\n\npir = Pin('G4',mode=Pin.IN, pull=Pin.PULL_UP)\n\n# main loop\nprint(\"Starting main loop\")\nwhile True:\n if pir() == 1:\n if time.time() - last_trigger > hold_time_sec:\n last_trigger = time.time()\n print(\"Presence detected, sending HTTP request\")\n try:\n return_code = d.setVariable('Presence:LivingRoom','1')\n print(\"Request result: \"+str(return_code))\n except Exception as e:\n print(\"Request failed\")\n print(e)\n else:\n last_trigger = 0\n print(\"No presence\")\n\n time.sleep_ms(500)\n\nprint(\"Exited main loop\")\n\nBoot (boot.py)\nFor more WiFi scripts, see the wlan step by step tutorial.\nimport os\nimport machine\n\nuart = machine.UART(0, 115200)\nos.dupterm(uart)\n\nknown_nets = {\n 'NetworkID': {'pwd': '', 'wlan_config': ('10.0.0.8', '255.255.0.0', '10.0.0.1', '10.0.0.1')},\n}\n\nfrom network import WLAN\nwl = WLAN()\n\n\nif machine.reset_cause() != machine.SOFT_RESET:\n\n wl.mode(WLAN.STA)\n original_ssid = wl.ssid()\n original_auth = wl.auth()\n\n print(\"Scanning for known wifi nets\")\n available_nets = wl.scan()\n nets = frozenset([e.ssid for e in available_nets])\n\n known_nets_names = frozenset([key for key in known_nets])\n net_to_use = list(nets & known_nets_names)\n try:\n net_to_use = net_to_use[0]\n net_properties = known_nets[net_to_use]\n pwd = net_properties['pwd']\n sec = [e.sec for e in available_nets if e.ssid == net_to_use][0]\n if 'wlan_config' in net_properties:\n wl.ifconfig(config=net_properties['wlan_config'])\n wl.connect(net_to_use, (sec, pwd), timeout=10000)\n while not wl.isconnected():\n machine.idle() # save power while waiting\n print(\"Connected to \"+net_to_use+\" with IP address:\" + wl.ifconfig()[0])\n\n except Exception as e:\n print(\"Failed to connect to any known network, going into AP mode\")\n wl.init(mode=WLAN.AP, ssid=original_ssid, auth=original_auth, channel=6, antenna=WLAN.INT_ANT)\n\nDomoticz Wrapper (domoticz.py)\nimport socket\nclass Domoticz:\n\n def __init__(self, ip, port, basic):\n self.basic = basic\n self.ip = ip\n self.port = port\n\n def setLight(self, idx, command):\n return self.sendRequest(\"type=command¶m=switchlight&idx=\"+idx+\"&switchcmd=\"+command)\n\n def setVariable(self, name, value):\n return self.sendRequest(\"type=command¶m=updateuservariable&vtype=0&vname=\"+name+\"&vvalue=\"+value)\n\n def sendRequest(self, path):\n try:\n s = socket.socket()\n s.connect((self.ip,self.port))\n s.send(b\"GET /json.htm?\"+path+\" HTTP/1.1\\r\\nHost: pycom.io\\r\\nAuthorization: Basic \"+self.basic+\"\\r\\n\\r\\n\")\n status = str(s.readline(), 'utf8')\n code = status.split(\" \")[1]\n s.close()\n return code\n\n except Exception:\n print(\"HTTP request failed\")\n return 0\n\n"},"tutorials/all/modbus.html":{"url":"tutorials/all/modbus.html","title":"Modbus","keywords":"","body":"Modbus\nModbus is a messaging protocol that defines the packet structure for transferring data between devices in a master/slave architecture. The protocol is independent of the transmission medium and is usually transmitted over TCP (MODBUS TCP) or serial communication (MODBUS RTU). Modbus is intended as a request/reply protocol and delivers services specified by function codes. The function code in the request tells the addressed slave what kind of action to perform. The function codes most commonly supported by devices are listed below.\n\n\n\nFunction Name\nFunction Code\n\n\n\n\nRead Coils\n0x01\n\n\nRead Discrete Inputs\n0x02\n\n\nRead Holding Registers\n0x03\n\n\nRead Input Registers\n0x04\n\n\nWrite Single Coil\n0x05\n\n\nWrite Single Register\n0x06\n\n\nWrite Multiple Coils\n0x0F\n\n\nWrite Multiple Registers\n0x10\n\n\n\nFor more information on the MODBUS RTU see the following PDF File. Information on the MODBUS TCP can be found here.\nPycom Modbus Library\nPython libraries and sample code that support Modbus TCP and Modbus RTU are available at the following GitHub Repository. To use this library, connect to the target Pycom device via ftp and upload the uModbus folder to /flash. A description of the supported function codes is found below.\nRead Coils\nThis function code requests the status (ON/OFF) of discrete coils on a remote device. The slave device address, the address of the first coil and the number of coils must be specified in the request. The address of the first coil is 0 and a maximum of 2000 contiguous coils can be read. Python sample code is shown below.\nslave_addr=0x0A\nstarting_address=0x00\ncoil_quantity=100\n\ncoil_status = modbus_obj.read_coils(slave_addr, starting_address, coil_quantity)\nprint('Coil status: ' + ' '.join('{:d}'.format(x) for x in coil_status))\n\nRead Discrete Inputs\nThis command is used to read the status (ON/OFF) of discrete inputs on a remote device. The slave address, the address of the first input, and the quantity of inputs to be read must be specified. The address of the first input is 0 and a maximum of 2000 continuous inputs can be read. The Python sample code is shown below.\nslave_addr=0x0A\nstarting_address=0x0\ninput_quantity=100\n\ninput_status = modbus_obj.read_discrete_inputs(slave_addr, starting_address, input_quantity)\nprint('Input status: ' + ' '.join('{:d}'.format(x) for x in input_status))\n\nRead Holding Registers\nThis function code is used to read the contents of analogue output holding registers. The slave address, the starting register address, the number of registers to read and the sign of the data must be specified. Register addresses start at 0 and a maximum of 125 continuous registers can be read.\nslave_addr=0x0A\nstarting_address=0x00\nregister_quantity=100\nsigned=True\n\nregister_value = modbus_obj.read_holding_registers(slave_addr, starting_address, register_quantity, signed)\nprint('Holding register value: ' + ' '.join('{:d}'.format(x) for x in register_value))\n\nRead Input Registers\nThis command is used to read up to 125 continuous input registers on a remote device. The slave address, the starting register address, the number of input registers and the sign of the data must be specified. The address of the first input registers is 0.\nslave_addr=0x0A\nstarting_address=0x00\nregister_quantity=100\nsigned=True\n\nregister_value = modbus_obj.read_input_registers(slave_addr, starting_address, register_quantity, signed)\nprint('Input register value: ' + ' '.join('{:d}'.format(x) for x in register_value))\n\nWrite Single Coil\nThis function code is used to write the state of a discrete coil on a remote device. A value of 0xFF00 means the coil should be set to ON, while a value of 0x0000 means the coil should be set to OFF. The Python sample code to set the coil at address 0x00, to an ON state is shown below.\nslave_addr=0x0A\noutput_address=0x00\noutput_value=0xFF00\n\nreturn_flag = modbus_obj.write_single_coil(slave_addr, output_address, output_value)\noutput_flag = 'Success' if return_flag else 'Failure'\nprint('Writing single coil status: ' + output_flag)\n\nWrite Single Register\nThis command is used to write the contents of an analog output holding register on a remote device. The slave address, the register address, the register value, and the signature of the data must be specified. As for all the other commands, the register addresses start from 0.\nslave_addr=0x0A\nregister_address=0x01\nregister_value=-32768\nsigned=True\n\nreturn_flag = modbus_obj.write_single_register(slave_addr, register_address, register_value, signed)\noutput_flag = 'Success' if return_flag else 'Failure'\nprint('Writing single coil status: ' + output_flag)\n\nWrite Multiple Coils\nThis function code is used to set a continuous sequence of coils, in a remote device, to either ON or OFF. The slave address, the starting address of the coils and an array with the coil states must be specified.\nslave_addr=0x0A\nstarting_address=0x00\noutput_values=[1,1,1,0,0,1,1,1,0,0,1,1,1]\n\nreturn_flag = modbus_obj.write_multiple_coils(slave_addr, starting_address, output_values)\noutput_flag = 'Success' if return_flag else 'Failure'\nprint('Writing multiple coil status: ' + output_flag)\n\nWrite Multiple Registers\nThis command is used to write the contents of a continuous sequence of analogue registers on a remote device. The slave address, the starting register address, the register values, and the signature of the data must be specified. The address of the first register is 0 and a maximum of 125 register values can be written. The Python sample code is shown below.\nslave_addr=0x0A\nregister_address=0x01\nregister_values=[2, -4, 6, -256, 1024]\nsigned=True\n\nreturn_flag = modbus_obj.write_multiple_registers(slave_addr, register_address, register_values, signed)\noutput_flag = 'Success' if return_flag else 'Failure'\nprint('Writing multiple register status: ' + output_flag)\n\n"},"tutorials/all/ota.html":{"url":"tutorials/all/ota.html","title":"OTA update","keywords":"","body":"OTA update\nOverview\nPycom modules come with the ability to update the devices firmware, while it is still running, we call this an \"over the air\" (OTA) update. The pycom library provides several functions to achieve this. This example will demonstrate how you could potentially use this functionality to update deployed devices. The full source code of this example can be found here.\nMethod\nHere we will describe one possible update methodology you could use that is implemented by this example.\nImagine you a smart metering company and you wish to roll out an update for your Pycom based smart meter. These meters usually send data back via LoRa. Unfortunately LoRa downlink messages have a very limited size and several hundred if not thousand would be required to upload a complete firmware image. To get around this you can have your devices sending their regular data via LoRa and when they receive a special command via a downlink message, the devices will connect to a WiFi network. It is unfeasible to ask customers to allow your device to connect to their home network so instead this network could be provided by a vehicle. This vehicle will travel around a certain geographic area in which the devices have been sent the special downlink message to initiate the update. The devices will look for the WiFi network being broadcast by the vehicle and connect. The devices will then connect to a server running on this WiFi network. This server (also shown in this example) will generate manifest files that instruct the device on what it should update, and where to get the update data from.\nServer\nCode available here.\nThis script runs a HTTP server on port 8000 that provisions over the air (OTA) update manifests in JSON format as well as serving the update content. This script should be run in a directory that contains every version of the end devices code, in the following structure:\n - server directory\n |- this_script.py\n |- 1.0.0\n | |- flash\n | | |- lib\n | | | |- lib_a.py\n | | |- main.py\n | | |- boot.py\n | |- sd\n | |- some_asset.txt\n | |- asset_that_will_be_removed.wav\n |- 1.0.1\n | |- flash\n | | |- lib\n | | | |- lib_a.py\n | | | |- new_lib.py\n | | |- main.py\n | | |- boot.py\n | |- sd\n | |- some_asset.txt\n |- firmware_1.0.0.bin\n |- firmware_1.0.1.bin\n\nThe top level directory that contains this script can contain one of two things:\n\nUpdate directory: These should be named with a version number compatible\nwith the python LooseVersion versioning scheme\n(http://epydoc.sourceforge.net/stdlib/distutils.version.LooseVersion-class.html).\nThey should contain the entire file system of the end device for the\ncorresponding version number.\n\nFirmware: These files should be named in the format firmare_VERSION.bin, where VERSION is a a version number compatible with the python LooseVersion versioning scheme (http://epydoc.sourceforge.net/stdlib/distutils.version.LooseVersion-class.html).\nThis file should be in the format of the appimg.bin created by the Pycom\nfirmware build scripts.\n\n\nHow to use\nOnce the directory has been setup as described above you simply need to start this script using python3. Once started this script will run a HTTP server on port 8000 (this can be changed by changing the PORT variable). This server will serve all the files in directory as expected along with one additional special file, manifest.json. This file does not exist on the file system but is instead generated when requested and contains the required changes to bring the end device from its current version to the latest available version. You can see an example of this by pointing your web browser at:\nhttp://127.0.0.1:8000/manifest.json?current_ver=1.0.0\nThe current_ver field at the end of the URL should be set to the current firmware version of the end device. The generated manifest will contain lists of which files are new, have changed or need to be deleted along with SHA1 hashes of the files. Below is an example of what such a manifest might look like:\n{\n \"delete\": [\n \"flash/old_file.py\",\n \"flash/other_old_file.py\"\n ],\n \"firmware\": {\n \"URL\": \"http://192.168.1.144:8000/firmware_1.0.1b.bin\",\n \"hash\": \"ccc6914a457eb4af8855ec02f6909316526bdd08\"\n },\n \"new\": [\n {\n \"URL\": \"http://192.168.1.144:8000/1.0.1b/flash/lib/new_lib.py\",\n \"dst_path\": \"flash/lib/new_lib.py\",\n \"hash\": \"1095df8213aac2983efd68dba9420c8efc9c7c4a\"\n }\n ],\n \"update\": [\n {\n \"URL\": \"http://192.168.1.144:8000/1.0.1b/flash/changed_file.py\",\n \"dst_path\": \"flash/changed_file.py\",\n \"hash\": \"1095df8213aac2983efd68dba9420c8efc9c7c4a\"\n }\n ],\n \"version\": \"1.0.1b\"\n}\n\nThe manifest contains the following fields:\n\ndelete: A list of paths to files which are no longer needed\nfirmware: The URL and SHA1 hash of the firmware image\nnew: the URL, path on end device and SHA1 hash of all new files\nupdate: the URL, path on end device and SHA1 hash of all files which\nexisted before but have changed.\n\nversion: The version number that this manifest will update the client to\n\nprevious_version: The version the client is currently on before applying\nthis update\n\n\nNote: The version number of the files might not be the same as the firmware. The highest available version number, higher than the current client version is used for both firmware and files. This may differ between the two.\nIn order for the URL's to be properly formatted you are required to send a \"host\" header along with your HTTP get request e.g:\nGET /manifest.json?current_ver=1.0.0 HTTP/1.0\\r\\nHost: 192.168.1.144:8000\\r\\n\\r\\n\n\nClient Library\nA MicroPyton library for interfacing with the server described above is available here.\nThis library is split into two layers. The top level OTA class implements all the high level functionality such as parsing the JSON file, making back copies of files being updated incase the update fails, etc. The layer of the library is agnostic to your chosen transport method. Below this is the WiFiOTA class. This class implements the actual transport mechanism of how the device fetches the files and update manifest (via WiFi as the class name suggests). The reason for this split is so that the high level functionality can be reused regardless of what transport mechanism you end up using. This could be implemented on top of Bluetooth for example, or the sever changed from HTTP to FTP.\nAlthough the above code is functional, it is provided only as an example of how an end user might implement a OTA update mechanism. It is not 100% feature complete e.g. even though it does backup previous versions of files, the roll back procedure is not implemented. This is left of the end user to do.\n\nExample\nBelow is am example implementing the methodology previously explained in this tutorial to initiate an OTA update.\nThe example below will only work on a Pycom device with LoRa capabilities. If want to test it out on a device without LoRa functionality then simply comment out any code relating to LoRa. Leaving just the WiFiOTA initialisation and they ota.connect() and ota.update()\n\nfrom network import LoRa, WLAN\nimport socket\nimport time\nfrom OTA import WiFiOTA\nfrom time import sleep\nimport pycom\nimport ubinascii\n\nfrom config import WIFI_SSID, WIFI_PW, SERVER_IP\n\n# Turn on GREEN LED\npycom.heartbeat(False)\npycom.rgbled(0xff00)\n\n# Setup OTA\nota = WiFiOTA(WIFI_SSID,\n WIFI_PW,\n SERVER_IP, # Update server address\n 8000) # Update server port\n\n# Turn off WiFi to save power\nw = WLAN()\nw.deinit()\n\n# Initialise LoRa in LORAWAN mode.\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\napp_eui = ubinascii.unhexlify('70B3D57ED0008CD6')\napp_key = ubinascii.unhexlify('B57F36D88691CEC5EE8659320169A61C')\n\n# join a network using OTAA (Over the Air Activation)\nlora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)\n\n# wait until the module has joined the network\nwhile not lora.has_joined():\n time.sleep(2.5)\n print('Not yet joined...')\n\n# create a LoRa socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\n# set the LoRaWAN data rate\ns.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)\n\n# make the socket blocking\n# (waits for the data to be sent and for the 2 receive windows to expire)\ns.setblocking(True)\n\nwhile True:\n # send some data\n s.send(bytes([0x04, 0x05, 0x06]))\n\n # make the socket non-blocking\n # (because if there's no data received it will block forever...)\n s.setblocking(False)\n\n # get any data received (if any...)\n data = s.recv(64)\n\n # Some sort of OTA trigger\n if data == bytes([0x01, 0x02, 0x03]):\n print(\"Performing OTA\")\n # Perform OTA\n ota.connect()\n ota.update()\n\n sleep(5)\n\n"},"tutorials/all/rmt.html":{"url":"tutorials/all/rmt.html","title":"RMT","keywords":"","body":"RMT\nDetailed information about this class can be found in RMT.\nThe RMT (Remote Control) peripheral of the ESP32 is primarily designed to send and receive infrared remote control signals that use on-off-keying of a carrier frequency, but due to its design it can be used to generate various types of signals, this class will allow you to do this.\nThe RMT has 7 channels, of which 5 are available and can be mapped to any GPIO pin (Note: Pins P13 -P18 can only be used as inputs).\n\n\n\nChannel\nResolution\nMaximum Pulse Width\n\n\n\n\n0\nUsed by on-board LED\n\n\n\n1\nUsed by pycom.pulses_get()\n\n\n\n2\n100nS\n3.2768 ms\n\n\n3\n100nS\n3.2768 ms\n\n\n4\n1000nS\n32.768 ms\n\n\n5\n1000nS\n32.768 ms\n\n\n6\n3125nS\n102.4 ms\n\n\n7\n3125nS\n102.4 ms\n\n\n\nTransmitting\nThe following examples create an RMT object on channel 4, configure it for transmission and send some data in various forms. The resolution of channel 4 is 1000 nano seconds, the given values are interpreted accordingly.\nIn this first example, we define the signal as a tuple of binary values that define the shape of the desired signal along with the duration of a bit.\nfrom machine import RMT\n# Map RMT channel 4 to P21, when the RMT is idle, it will output LOW\nrmt = RMT(channel=4, gpio=\"P21\", tx_idle_level=RMT.LOW)\n\n# Produces the pattern shown in data, where each bit lasts\n# duration * channel resolution = 10000 * 1000ns = 10ms\ndata = (1,0,1,1,1,0,1,0,1)\nduration = 10000\nrmt.pulses_send(duration, data)\n\n\nIn this example we define the signal by a tuple of durations and what state the signal starts in.\nfrom machine import RMT\n# Map RMT channel 4 to P21, when the RMT is idle, it will output LOW\nrmt = RMT(channel=4, gpio=\"P21\", tx_idle_level=RMT.LOW)\n\n# The list of durations for each pulse to be, these are in units of the channels\n# resolution:\n# duration = Desired pulse length / Channel Resolution\nduration = (8000,11000,8000,11000,6000,13000,6000,3000,8000)\n\n# `start_level` defines if the signal starts off as LOW or HIGH, it will then\n# toggle state between each duration\nrmt.pulses_send(duration, start_level=RMT.HIGH)\n\n\nThis third example, is a combination of the above two styles of defining a signal. Each pulse has a defined duration as well as a state. This is useful if you don't always want the signal to toggle state.\nfrom machine import RMT\n# Map RMT channel 4 to P21, when the RMT is idle, it will output LOW\nrmt = RMT(channel=4, gpio=\"P21\", tx_idle_level=RMT.LOW)\n\n# Produces the pattern shown in data, where each bit lasts\n# duration[i] * channel resolution = duration[i] * 1000ns\ndata = (1,0,1,1,0,1)\nduration = (400,200,100,300,200,400)\nrmt.pulses_send(duration, data)\n\n\nThe following example creates an RMT object on channel 4 and configures it for transmission with carrier modulation.\nfrom machine import RMT\nrmt = RMT(channel=4,\n gpio=\"P21\",\n tx_idle_level=RMT.LOW,\n # Carrier = 100Hz, 80% duty, modules HIGH signals\n tx_carrier = (100, 70, RMT.HIGH)) \ndata = (1,0,1)\nduration = 10000\nrmt.pulses_send(duration, data)\n\n\nThe following example creates an RMT object on channel 2, configures it for receiving, then waits for the first, undefined number of pulses without timeout\nfrom machine import RMT\nrmt = machine.RMT(channel=2)\nrmt.init(gpio=\"P21\", rx_idle_threshold=1000)\n\ndata = rmt.pulses_get()\n\nIf tx_idle_level is not set to the opposite of the third value in the tx_carrier tuple, the carrier wave will continue to be generated when the RMT channel is idle.\n\nReceiving\nThe following example creates an RMT object on channel 2, configures it for receiving a undefined number of pulses, then waits maximum of 1000us for the first pulse.\nfrom machine import RMT\n# Sets RMT channel 2 to P21 and sets the maximum length of a valid pulse to\n# 1000*channel resolution = 1000 * 100ns = 100us\nrmt = machine.RMT(channel=2, gpio=\"P21\", rx_idle_threshold=1000)\nrmt.init()\n\n# Get a undefined number of pulses, waiting a maximum of 500us for the first\n# pulse (unlike other places where the absolute duration was based on the RMT\n# channels resolution, this value is in us) until a pulse longer than\n# rx_idle_threshold occurs.\ndata = rmt.pulses_get(timeout=500)\n\nThe following example creates an RMT object on channel 2, configures it for receiving, filters out pulses with width \nfrom machine import RMT\n\nrmt = machine.RMT(channel=2, # Resolution = 100ns\n gpio=\"P21\",\n # Longest valid pulse = 1000*100ns = 100us\n rx_idle_threshold=1000,\n # Filter out pulses shorter than 20*100ns = 2us\n rx_filter_threshold=20)\n\n# Receive 100 pulses, pulses shorter than 2us or longer than 100us will be\n# ignored. That means if it receives 80 valid pulses but then the signal\n# doesn't change for 10 hours and then 20 more pulses occur, this function\n# will wait for 10h\ndata = rmt.pulses_get(pulses=100)\n\n"},"tutorials/lora/":{"url":"tutorials/lora/","title":"LoRa Examples","keywords":"","body":"LoRa Examples\nThe following tutorials demonstrate the use of the LoRa functionality on the LoPy. LoRa can work in 2 different modes; LoRa-MAC (which we also call Raw-LoRa) and LoRaWAN mode.\nLoRa-MAC mode basically accesses de radio directly and packets are sent using the LoRa modulation on the selected frequency without any headers, addressing information or encryption. Only a CRC is added at the tail of the packet and this is removed before the received frame is passed on to the application. This mode can be used to build any higher level protocol that can benefit from the long range features of the LoRa modulation. Typical uses cases include LoPy to LoPy direct communication and a LoRa packet forwarder.\nLoRaWAN mode implements the full LoRaWAN stack for a class A device. It supports both OTAA and ABP connection methods, as well as advanced features like adding and removing custom channels to support \"special\" frequencies plans like the those used in New Zealand.\n"},"tutorials/lora/lora-mac.html":{"url":"tutorials/lora/lora-mac.html","title":"LoRa-MAC (Raw LoRa)","keywords":"","body":"LoRa-MAC (Raw LoRa)\nBasic LoRa connection example, sending and receiving data. In LoRa-MAC mode the LoRaWAN layer is bypassed and the radio is used directly. The data sent is not formatted or encrypted in any way, and no addressing information is added to the frame.\nFor the example below, you will need two LoPys. A while loop with a random delay time is used to minimise the chances of the 2 LoPy's transmitting at the same time. Run the code below on the 2 LoPy modules and you will see the word 'Hello' being received on both sides.\nfrom network import LoRa\nimport socket\nimport machine\nimport time\n\n# initialise LoRa in LORA mode\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\n# more params can also be given, like frequency, tx power and spreading factor\nlora = LoRa(mode=LoRa.LORA, region=LoRa.EU868)\n\n# create a raw LoRa socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\nwhile True:\n # send some data\n s.setblocking(True)\n s.send('Hello')\n\n # get any data received...\n s.setblocking(False)\n data = s.recv(64)\n print(data)\n\n # wait a random amount of time\n time.sleep(machine.rng() & 0x0F)\n\n"},"tutorials/lora/lorawan-otaa.html":{"url":"tutorials/lora/lorawan-otaa.html","title":"LoRaWAN with OTAA","keywords":"","body":"LoRaWAN with OTAA\nOTAA stands for Over The Air Authentication. With this method the LoPy sends a Join request to the LoRaWAN Gateway using the APPEUI and APPKEY provided. If the keys are correct the Gateway will reply to the LoPy with a join accept message and from that point on the LoPy is able to send and receive packets to/from the Gateway. If the keys are incorrect no response will be received and the has_joined() method will always return False.\nThe example below attempts to get any data received after sending the frame. Keep in mind that the Gateway might not be sending any data back, therefore we make the socket non-blocking before attempting to receive, in order to prevent getting stuck waiting for a packet that will never arrive.\nfrom network import LoRa\nimport socket\nimport time\nimport ubinascii\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\n# create an OTAA authentication parameters\napp_eui = ubinascii.unhexlify('ADA4DAE3AC12676B')\napp_key = ubinascii.unhexlify('11B0282A189B75B0B4D2D8C7FA38548B')\n\n# join a network using OTAA (Over the Air Activation)\nlora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)\n\n# wait until the module has joined the network\nwhile not lora.has_joined():\n time.sleep(2.5)\n print('Not yet joined...')\n\n# create a LoRa socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\n# set the LoRaWAN data rate\ns.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)\n\n# make the socket blocking\n# (waits for the data to be sent and for the 2 receive windows to expire)\ns.setblocking(True)\n\n# send some data\ns.send(bytes([0x01, 0x02, 0x03]))\n\n# make the socket non-blocking\n# (because if there's no data received it will block forever...)\ns.setblocking(False)\n\n# get any data received (if any...)\ndata = s.recv(64)\nprint(data)\n\n"},"tutorials/lora/lorawan-abp.html":{"url":"tutorials/lora/lorawan-abp.html","title":"LoRaWAN with ABP","keywords":"","body":"LoRaWAN with ABP\nABP stands for Authentication By Personalisation. It means that the encryption keys are configured manually on the device and can start sending frames to the Gateway without needing a 'handshake' procedure to exchange the keys (such as the one performed during an OTAA join procedure).\nThe example below attempts to get any data received after sending the frame. Keep in mind that the Gateway might not be sending any data back, therefore we make the socket non-blocking before attempting to receive, in order to prevent getting stuck waiting for a packet that will never arrive.\nfrom network import LoRa\nimport socket\nimport ubinascii\nimport struct\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\n# create an ABP authentication params\ndev_addr = struct.unpack(\">l\", ubinascii.unhexlify('00000005'))[0]\nnwk_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\napp_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\n\n# join a network using ABP (Activation By Personalization)\nlora.join(activation=LoRa.ABP, auth=(dev_addr, nwk_swkey, app_swkey))\n\n# create a LoRa socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\n# set the LoRaWAN data rate\ns.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)\n\n# make the socket blocking\n# (waits for the data to be sent and for the 2 receive windows to expire)\ns.setblocking(True)\n\n# send some data\ns.send(bytes([0x01, 0x02, 0x03]))\n\n# make the socket non-blocking\n# (because if there's no data received it will block forever...)\ns.setblocking(False)\n\n# get any data received (if any...)\ndata = s.recv(64)\nprint(data)\n\n"},"tutorials/lora/lora-mac-nano-gateway.html":{"url":"tutorials/lora/lora-mac-nano-gateway.html","title":"LoRa-MAC Nano-Gateway","keywords":"","body":"LoRa-MAC Nano-Gateway\nThis example allows a raw LoRa connection between two LoPys (nodes) to a single LoPy acting as a Nano-Gateway.\nFor more information and discussions about this code, see this forum post.\nGateway Code\nimport socket\nimport struct\nfrom network import LoRa\n\n# A basic package header, B: 1 byte for the deviceId, B: 1 byte for the pkg size, %ds: Formatted string for string\n_LORA_PKG_FORMAT = \"!BB%ds\"\n# A basic ack package, B: 1 byte for the deviceId, B: 1 byte for the pkg size, B: 1 byte for the Ok (200) or error messages\n_LORA_PKG_ACK_FORMAT = \"BBB\"\n\n# Open a LoRa Socket, use rx_iq to avoid listening to our own messages\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORA, rx_iq=True, region=LoRa.EU868)\nlora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\nlora_sock.setblocking(False)\n\nwhile (True):\n recv_pkg = lora_sock.recv(512)\n if (len(recv_pkg) > 2):\n recv_pkg_len = recv_pkg[1]\n\n device_id, pkg_len, msg = struct.unpack(_LORA_PKG_FORMAT % recv_pkg_len, recv_pkg)\n\n# If the uart = machine.UART(0, 115200) and os.dupterm(uart) are set in the boot.py this print should appear in the serial port\n print('Device: %d - Pkg: %s' % (device_id, msg))\n\n ack_pkg = struct.pack(_LORA_PKG_ACK_FORMAT, device_id, 1, 200)\n lora_sock.send(ack_pkg)\n\nThe _LORA_PKG_FORMAT is used as a method of identifying the different devices within a network. The _LORA_PKG_ACK_FORMAT is a simple ack package as a response to the nodes package.\nNode\nimport os\nimport socket\nimport time\nimport struct\nfrom network import LoRa\n\n# A basic package header, B: 1 byte for the deviceId, B: 1 byte for the pkg size\n_LORA_PKG_FORMAT = \"BB%ds\"\n_LORA_PKG_ACK_FORMAT = \"BBB\"\nDEVICE_ID = 0x01\n\n\n# Open a Lora Socket, use tx_iq to avoid listening to our own messages\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORA, tx_iq=True, region=LoRa.EU868)\nlora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\nlora_sock.setblocking(False)\n\nwhile(True):\n # Package send containing a simple string\n msg = \"Device 1 Here\"\n pkg = struct.pack(_LORA_PKG_FORMAT % len(msg), DEVICE_ID, len(msg), msg)\n lora_sock.send(pkg)\n\n # Wait for the response from the gateway. NOTE: For this demo the device does an infinite loop for while waiting the response. Introduce a max_time_waiting for you application\n waiting_ack = True\n while(waiting_ack):\n recv_ack = lora_sock.recv(256)\n\n if (len(recv_ack) > 0):\n device_id, pkg_len, ack = struct.unpack(_LORA_PKG_ACK_FORMAT, recv_ack)\n if (device_id == DEVICE_ID):\n if (ack == 200):\n waiting_ack = False\n # If the uart = machine.UART(0, 115200) and os.dupterm(uart) are set in the boot.py this print should appear in the serial port\n print(\"ACK\")\n else:\n waiting_ack = False\n # If the uart = machine.UART(0, 115200) and os.dupterm(uart) are set in the boot.py this print should appear in the serial port\n print(\"Message Failed\")\n\n time.sleep(5)\n\nThe node is always sending packages and waiting for the ack from the gateway.\nTo adapt this code to user specific needs:\n\nPut a max waiting time for the ack to arrive and resend the package or mark it as invalid\nIncrease the package size changing the _LORA_PKG_FORMAT to BH%ds. The H will allow the keeping of 2 bytes for size (for more information about struct format)\nReduce the package size with bitwise manipulation\nReduce the message size (for this demo, a string) to something more useful for specific development\n\n\n"},"tutorials/lora/module-module.html":{"url":"tutorials/lora/module-module.html","title":"LoPy to LoPy","keywords":"","body":"LoPy to LoPy\nThis example shows how to connect two Pycode LoRa capable modules (nodes) via raw LoRa.\nNode A\nfrom network import LoRa\nimport socket\nimport time\n\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORA, region=LoRa.EU868)\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\ns.setblocking(False)\n\nwhile True:\n if s.recv(64) == b'Ping':\n s.send('Pong')\n time.sleep(5)\n\nNode B\nfrom network import LoRa\nimport socket\nimport time\n\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORA, region=LoRa.EU868)\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\ns.setblocking(False)\nwhile True:\n s.send('Ping')\n time.sleep(5)\n\n"},"tutorials/lora/rn2483-to-lopy.html":{"url":"tutorials/lora/rn2483-to-lopy.html","title":"RN2483 to LoPy","keywords":"","body":"RN2483 to LoPy\nThis example shows how to send data between a Microchip RN2483 and a LoPy via raw LoRa.\nRN2483\nmac pause\nradio set freq 868000000\n\nradio set mod lora\nradio set bw 250\nradio set sf sf7\nradio set cr 4/5\nradio set bw 125\nradio set sync 12\nradio set prlen 8\n\n# Transmit via radio tx:\nradio tx 48656c6C6F #(should send ‘Hello')\n\nLoPy\nfrom network import LoRa\nimport socket\n\nlora = LoRa(mode=LoRa.LORA, frequency= 868000000, bandwidth=LoRa.BW_125KHZ, sf=7, preamble=8,\n coding_rate=LoRa.CODING_4_5, power_mode=LoRa.ALWAYS_ON,\n tx_iq=False, rx_iq=False, public=False)\n\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\n# This keeps listening for data \"forever\".\nwhile(True):\n s.recv(64)\n\n"},"tutorials/sigfox.html":{"url":"tutorials/sigfox.html","title":"Sigfox Examples","keywords":"","body":"Sigfox Examples\nBefore you start, make sure that your device was registered with Sigfox.\nThe following tutorials demonstrate how to register and get started with the SiPy. The board can be configured for operation in various countries based upon specified RCZ zones (see the Sigfox class for more info). The SiPy, LoPy 4, and FiPy supports both uplink and downlink Sigfox messages as well as device to device communication via its FSK Mode Sigfox.\nfrom network import Sigfox\nimport socket\n​\n# init Sigfox for RCZ1 (Europe)\nsigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)\n​\n# create a Sigfox socket\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\n​\n# make the socket blocking\ns.setblocking(True)\n​\n# configure it as uplink only\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False)\n​\n# send some bytes\ns.send(bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]))\n\nPlease ensure that there is an antenna connected to your device before sending/receiving Sigfox messages as in proper use (e.g. without an antenna), may damage the device.\n\nDisengage Sequence Number\nIf your are experiencing issues with Sigfox connectivity, this could be due to the sequence number being out of sync. To prevent replay on the network, the Sigfox protocol uses sequence numbers. If there is a large difference between the sequence number sent by the device and the one expected by the backend, your message is dropped by the network.\nYou can use the Disengage sequence number button on the device information or on the device type information page of the Sigfox backend to reset the number expected by the backend. If the sequence number of your next message is different from the last trashed sequence number, the message will be accepted.\nIssues with the sequence number can occur when a lot of messages are sent when outside of Sigfox coverage for instance.\nFirstly you will need to log into the Sigfox Backend, navigate to device, and click on the Sigfox ID of the affected SiPy.\n\nYou should now see the Information page with an entry Device Type: followed by a link. Please follow the link\n\nFinally, on this page click on Disengage sequence number button in the upper right corner.\n\n"},"tutorials/lte/":{"url":"tutorials/lte/","title":"LTE Examples","keywords":"","body":"LTE Examples\nThe following tutorials demonstrate the use of the LTE CAT-M1 and NB-IoT functionality on cellular enabled Pycom modules.\nOur cellular modules support both LTE CAT-M1 and NB-IoT, these are new lower power, long range, cellular protocols. These are not the same as the full version of 2G/3G/LTE supported by cell phones, and require your local carriers to support them. At the time of writing, CAT-M1 and NB-IoT connectivity is not widely available so be sure to check with local carriers if support is available where you are.\n"},"tutorials/lte/cat-m1.html":{"url":"tutorials/lte/cat-m1.html","title":"CAT-M1","keywords":"","body":"CAT-M1\nPlease ensure you have the latest Sequans modem firmware for the best network compatibility. Instructions for this can be found here.\n\nThe LTE Cat M1 service gives full IP access through the cellular modem.\nOnce the lte.connect() function has completed all the IP socket functions - including SSL - will be routed through this connection. This mean any code using WLAN can be adapted to Cat M1 by simply adding the connection setup step first and disconnect after.\nFor example to connect over LTE Cat M1 to Google's web server over secure SSL:\nimport socket\nimport ssl\nimport time\nfrom network import LTE\n\nlte = LTE() # instantiate the LTE object\nlte.attach() # attach the cellular modem to a base station\nwhile not lte.isattached():\n time.sleep(0.25)\nlte.connect() # start a data session and obtain an IP address\nwhile not lte.isconnected():\n time.sleep(0.25)\n\ns = socket.socket()\ns = ssl.wrap_socket(s)\ns.connect(socket.getaddrinfo('www.google.com', 443)[0][-1])\ns.send(b\"GET / HTTP/1.0\\r\\n\\r\\n\")\nprint(s.recv(4096))\ns.close()\n\nlte.disconnect()\nlte.dettach()\n\nThis also applies to our MQTT and AWS examples.\nIMPORTANT: Once the LTE radio is initialised, it must be de-initialised before going to deepsleep in order to ensure minimum power consumption. This is required due to the LTE radio being powered independently and allowing use cases which require the system to be taken out from deepsleep by an event from the LTE network (data or SMS received for instance).\nWhen using the expansion board and the FiPy together, the RTS/CTS jumpers MUST be removed as those pins are being used by the LTE radio. Keeping those jumpers in place will lead to erratic operation and higher current consumption specially while in deepsleep.\n"},"tutorials/lte/nb-iot.html":{"url":"tutorials/lte/nb-iot.html","title":"NB-IoT","keywords":"","body":"NB-IoT\nLTE class for Narrow Band IoT\nAs shipped, Pycom modules only support CAT-M1, in order to use NB-IoT you need to flash a different firmware to the Sequans modem. Instructions for this can be found here.\n\nNB-IoT usage\nExample with Vodafone:\nfrom network import LTE\n\nlte = LTE()\nlte.send_at_cmd('AT+CFUN=0')\nlte.send_at_cmd('AT!=\"clearscanconfig\"')\nlte.send_at_cmd('AT!=\"addscanband band=20\"')\nlte.send_at_cmd('AT!=\"disablelog 1\"')\nlte.send_at_cmd('AT+CGDCONT=1,\"IP\",\"nb.inetd.gdsp\"')\nlte.send_at_cmd('AT+CFUN=1')\n\nwhile not lte.isattached():\n pass\n\nlte.connect()\nwhile not lte.isconnected():\n pass\n\n# now use socket as usual...\n\nIMPORTANT: Once the LTE radio is initialised, it must be de-initialised before going to deepsleep in order to ensure minimum power consumption. This is required due to the LTE radio being powered independently and allowing use cases which require the system to be taken out from deepsleep by an event from the LTE network (data or SMS received for instance).\nWhen using the expansion board and the FiPy together, the RTS/CTS jumpers MUST be removed as those pins are being used by the LTE radio. Keeping those jumpers in place will lead to erratic operation and higher current consumption specially while in deepsleep.\n"},"tutorials/lte/imei.html":{"url":"tutorials/lte/imei.html","title":"Module IMEI","keywords":"","body":"Module IMEI\nIn order to retrieve the IMEI of your cellular enabled Pycom module you will firstly need to make sure you are on firmware version 1.17.0.b1 or higher. You can check your firmware version by running the following code on you device via the interactive REPL.\n>>> import os\n>>> os.uname()\n(sysname='GPy', nodename='GPy', release='1.17.0.b1', version='v1.8.6-849-d0dc708 on 2018-02-27', machine='GPy with ESP32')\n\nOnce you have a compatible firmware, you can run the following code to get your modules IMEI number:\nfrom network import LTE\nlte = LTE()\nlte.send_at_cmd('AT+CGSN=1')\n\nYou'll get a return string like this \\r\\n+CGSN: \"354347xxxxxxxxx\"\\r\\n\\r\\nOK. The value between the double quotes is your IMEI.\n"},"tutorials/lte/firmware.html":{"url":"tutorials/lte/firmware.html","title":"Modem Firmware Update","keywords":"","body":"Modem Firmware Update\nThis article is only related to GPy, FiPy, and G01 boards\n\nImportant: When upgrading your modem for the first time, even if you have updated it in the past with the old firmware update method, you MUST use the \"recovery\" upgrade method described below. Otherwise you will risk breaking your module\n\nPlease read the following instructions carefully as there are some significant changes compared to the previous updater version.\nMost importantly, the updater is now integrated in the latest stable firmware release (we will also publish a new development and pybytes firmware in the coming days), so you no longer need to upload any scripts to your module. The built-in updater will take precedence over any scripts uploaded.\nPlease start with the following steps:\n\nUpgrade the Pycom Firmware Updater tool to latest version\nSelect Firmware Type stable in the communication window to upgrade to version v1.18.1.r1\n\nYou can find the different versions of firmwares available here: https://software.pycom.io/downloads/sequans2.html\nWe are using CATM1-38638.zip and NB1-37781.zip as examples in this tutorial.\nAfter unpacking the zip archive, you will find each firmware packages contains two files, one being the firmware file (e.g. CATM1-38638.dup or NB1-37781.dup) and the updater.elf file, which is required when using the \"recovery\" firmware update method or if a previous upgrade failed and the modem is in recovery mode.\nPlease note that the updater.elf file is only around 300K so you can also store it inside the flash file system of the module. The firmware dup files will NOT fit into the available /flash file system on the module, so you either need to use an SD card or upload it directly from your computer.\nVia SD card\nTo transfer the firmware files onto the SD card you have two options:\n\nFormat your SD card as with the FAT file system and then copy the files onto the card using your computer\nMake sure your SD card has an MBR and a single primary partition, the format it directly on the module, mount it and transfer the firmware files onto the SD card using FTP. Please ensure the transfer is successful and that each file on the module has the same size as the original file on your PC.\n\nfrom machine import SD\n\nsd = SD()\nos.mkfs(sd) # format SD card\nos.mount(sd, '/sd') # mount it\nos.listdir('/sd') # list its content\n\nOnce you copied/uploaded the firmware files on to the SD card you can flash the LTE modem using the following command:\nTo flash the CAT-M1 firmware onto your device using the recovery method:\nimport sqnsupgrade\nsqnsupgrade.run('/sd/CATM1-38638.dup', '/sd/updater.elf')\n\nTo flash the NB-IoT firmware onto your device using the recovery method:\nimport sqnsupgrade\nsqnsupgrade.run('/sd/NB1-37781.dup', '/sd/updater.elf')\n\nPlease note you can directly flash the desired firmware onto your module, it is not necessary to upgrade to the latest CAT-M1 firmware before switching to NB-IoT.\nIf you have already mounted the SD card, please use the path you used when mounting it. Otherwise, if an absolute path other than /flash is specified, the script will automatically mount the SD card using the path specified.\nOnce update is finished successfully you will have a summary of new updated versions. The full output from the upgrade will looks similar to this:\n>>\nAttempting AT wakeup...\nStarting STP (DO NOT DISCONNECT POWER!!!)\nSession opened: version 1, max transfer 8192 bytes\nSending 54854 bytes: [########################################] 100%\nBootrom updated successfully, switching to upgrade mode\nAttempting AT auto-negotiation...\nSession opened: version 1, max transfer 2048 bytes\nSending 306076 bytes: [########################################] 100%\nAttempting AT wakeup...\nUpgrader loaded successfully, modem is in upgrade mode\nAttempting AT wakeup...\nStarting STP ON_THE_FLY\nSession opened: version 1, max transfer 8192 bytes\nSending 5996938 bytes: [########################################] 100%\nCode download done, returning to user mode\nResetting (DO NOT DISCONNECT POWER!!!)................\nUpgrade completed!\nHere's the current firmware version:\n\nSYSTEM VERSION\n==============\n FIRMWARE VERSION\n Bootloader0 : 5.1.1.0 [33080]\n Bootloader1 : 5.1.1.0 [38638]\n Bootloader2* : 5.1.1.0 [38638]\n NV Info : 1.1,0,0\n Software : 5.1.1.0 [38638] by robot-soft at 2018-08-20 09:51:46\n UE : 5.0.0.0d\n COMPONENTS\n ZSP0 : 1.0.99-13604\n ZSP1 : 1.0.99-12341\n\nPlease note that the firmware update may seem to \"stall\" around 7-10% and again at 99%. This is not an indication of a failure but the fact that the modem has to do some tasks during and the updater will wait for these tasks to be completed. Unless the upgrade process is hanging for more than 5 minutes, do not interrupt the process as you will have to start again if you don't finish it. It may also take several minutes for the updater to load before responding to the AT wakeup command.\n\nAfter you have updated your modem once using the recovery method, you can now flash your modem again using just the CATM1-38638.dup or NB1-37781.dup file without specifying the updater.elf file. However, should the upgrade fail, your modem may end up in recovery mode and you will need the updater.elf file again. The updater will check for this and prompt you if using the updater.elf file is necessary.\nExample output using just the firmware file:\n>>\nAttempting AT wakeup...\n\nStarting STP ON_THE_FLY\nSession opened: version 1, max transfer 8192 bytes\nSending 5996938 bytes: [########################################] 100%\nCode download done, returning to user mode\nResetting (DO NOT DISCONNECT POWER!!!)............................................................................\nUpgrade completed!\nHere's the current firmware version:\n\nSYSTEM VERSION\n==============\n FIRMWARE VERSION\n Bootloader0 : 5.1.1.0 [33080]\n Bootloader1* : 5.1.1.0 [38638]\n Bootloader2 : 5.1.1.0 [38638]\n NV Info : 1.1,0,0\n Software : 5.1.1.0 [38638] by robot-soft at 2018-08-20 09:51:46\n UE : 5.0.0.0d\n COMPONENTS\n ZSP0 : 1.0.99-13604\n ZSP1 : 1.0.99-12341\n\nVia UART Serial Interface\nIf you can't use an SD card to hold the firmware images, you can use the existing UART interface you have with the board to load these firmware files from your Computer.\nYou will need the following software installed on your computer:\n\nPython 3, if it's not directly available through your OS distributor\nPySerial\n\nYou will also need to download the following Python scripts: https://github.com/pycom/pycom-libraries/tree/master/lib/sqnsupgrade\nImportant: When upgrading your modem for the first time, even if you have updated it in the past with the old firmware update method, you MUST use the \"recovery\" upgrade method described below. Otherwise, you will risk breaking your module.\nYou can upload the updater.elf file to the module's flash file system rather than uploading it via UART directly to the modem, which will slightly increase the speed of the upgrade.\nFirst, you need to prepare your modem for upgrade mode by using the following commands.\nCommands to run on the Pycom module\nTo use the recovery method:\nimport sqnsupgrade\nsqnsupgrade.uart(True)\n\nTo use the recovery method using the updater.elf file on the module:\n import sqnsupgrade\n sqnsupgrade.uart(True,'/flash/updater.elf')\n\nTo use the normal method:\n import sqnsupgrade\n sqnsupgrade.uart()\n\nAfter this command is executed a message will be displayed asking you to close the port.\nGoing into MIRROR mode... please close this terminal to resume the upgrade via UART\n\nCommands to be run on your computer\nYou must close the terminal/Atom or Visual Studio Code console to run the following commands from your computer:\nGo to the directory where you saved the sqnsupgrade scripts and run the following commands in terminal:\nWhen using the recovery method:\n$ python3\nPython 3.6.5 (default, Apr 25 2018, 14:23:58)\n[GCC 4.2.1 Compatible Apple LLVM 9.1.0 (clang-902.0.39.1)] on darwin\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>>\n>>> import sqnsupgrade\n>>> sqnsupgrade.run('Serial_Port', '/path/to/CATM1-38638.dup', '/path/to/updater.elf')\n\nWhen using the standard method (or if the updater.elf was loaded on the module):\n $ python3\n Python 3.6.5 (default, Apr 25 2018, 14:23:58)\n [GCC 4.2.1 Compatible Apple LLVM 9.1.0 (clang-902.0.39.1)] on darwin\n Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n >>>\n >>> import sqnsupgrade\n >>> sqnsupgrade.run('Serial_Port', '/path/to/CATM1-38638.dup')\n\nPlease note that the firmware update may seem to \"stall\" around 7-10% and again at 99%. This is not an indication of a failure but the fact that the modem has to do some tasks during and the updater will wait for these tasks to be completed. Unless the upgrade process is hanging for more than 5 minutes, do not interrupt the process as you will have to start again if you don't finish it. It may also take several minutes for the updater to load before responding to the AT wakeup command.\nRetrying process\nIn case of any failure or interruption to the process of LTE modem upgrade you can repeat the same steps after doing a hard reset to the board (i.e disconnecting and reconnecting power), pressing the reset button is not enough.\n"},"tutorials/pytrack.html":{"url":"tutorials/pytrack.html","title":"Pytrack Examples","keywords":"","body":"Pytrack Examples\nBoth the Pysense and Pytrack use the same accelerometer. Please see the Pysense Examples to see how to use the accelerometer.\nExample\nYou can find this example in the pycom/pycom-libraries GitHub repository.\nimport machine\nimport math\nimport network\nimport os\nimport time\nimport utime\nimport gc\nfrom machine import RTC\nfrom machine import SD\nfrom L76GNSS import L76GNSS\nfrom pytrack import Pytrack\n\ntime.sleep(2)\ngc.enable()\n\n# setup rtc\nrtc = machine.RTC()\nrtc.ntp_sync(\"pool.ntp.org\")\nutime.sleep_ms(750)\nprint('\\nRTC Set from NTP to UTC:', rtc.now())\nutime.timezone(7200)\nprint('Adjusted from UTC to EST timezone', utime.localtime(), '\\n')\n\npy = Pytrack()\nl76 = L76GNSS(py, timeout=30)\n\n# sd = SD()\n# os.mount(sd, '/sd')\n# f = open('/sd/gps-record.txt', 'w')\n\nwhile (True):\n coord = l76.coordinates()\n #f.write(\"{} - {}\\n\".format(coord, rtc.now()))\n print(\"{} - {} - {}\".format(coord, rtc.now(), gc.mem_free()))\n\nAlternative Libraries\n\nmicropyGPS\nAlternative L76GNSS module\n\n"},"tutorials/pysense.html":{"url":"tutorials/pysense.html","title":"Pysense Examples","keywords":"","body":"Pysense Examples\nAccelerometer\nThis basic example shows how to read pitch and roll from the on-board accelerometer and output it in comma separated value (CSV) format over serial.\nfrom LIS2HH12 import LIS2HH12\nfrom pytrack import Pytrack\npy = Pytrack()\nacc = LIS2HH12()\n\nwhile True:\n pitch = acc.pitch()\n roll = acc.roll()\n print('{},{}'.format(pitch, roll))\n time.sleep_ms(100)\n\n\nIf you want to visualise the data output by this script a Processing sketch is available here that will show the board orientation in 3D.\n"},"tutorials/pyscan.html":{"url":"tutorials/pyscan.html","title":"Pyscan Examples","keywords":"","body":"Pyscan Examples\nThis basic example shows how to read an NFC card and authenticate it using a pre-defined access list.\nfrom pyscan import Pyscan\nfrom MFRC630 import MFRC630\nimport time\nimport pycom\nimport _thread\n\nVALID_CARDS = [[0x43, 0x95, 0xDD, 0xF8],\n [0x43, 0x95, 0xDD, 0xF9]]\n\npy = Pyscan()\nnfc = MFRC630(py)\n\nRGB_BRIGHTNESS = 0x8\n\nRGB_RED = (RGB_BRIGHTNESS 0):\n if (check_uid(list(uid), uid_len)) > 0:\n pycom.rgbled(RGB_GREEN)\n else:\n pycom.rgbled(RGB_RED)\n else:\n # No card detected\n pycom.rgbled(RGB_BLUE)\n nfc.mfrc630_cmd_reset()\n time.sleep(.5)\n nfc.mfrc630_cmd_init()\n\n# This is the start of our main execution... start the thread\n_thread.start_new_thread(discovery_loop, (nfc, 0))\n\nYou can find this, and all the other examples in our pycom-libraries GitHub repository\n"},"firmwareapi/introduction.html":{"url":"firmwareapi/introduction.html","title":"Introduction","keywords":"","body":"Introduction\nThis chapter describes modules (function and class libraries) that are built into MicroPython. There are a number of categories for the available modules:\n\nModules which implement a subset of standard Python functionality and are not intended to be extended by the user.\nModules which implement a subset of Python functionality, with a provision for extension by the user (via Python code).\nModules which implement MicroPython extensions to the Python standard libraries.\nModules specific to a particular port and thus not portable.\n\nNote about the availability of modules and their contents\nThis documentation in general aspires to describe all modules and functions/classes which are implemented in MicroPython. However, MicroPython is highly configurable, and each port to a particular board/embedded system makes available only a subset of MicroPython libraries. For officially supported ports, there is an effort to either filter out non-applicable items, or mark individual descriptions with “Availability:” clauses describing which ports provide a given feature. With that in mind, please still be warned that some functions/classes in a module (or even the entire module) described in this documentation may be unavailable in a particular build of MicroPython on a particular board. The best place to find general information of the availability/non-availability of a particular feature is the “General Information” section which contains information pertaining to a specific port.\nBeyond the built-in libraries described in this documentation, many more modules from the Python standard library, as well as further MicroPython extensions to it, can be found in the micropython-lib repository.\n"},"firmwareapi/pycom/":{"url":"firmwareapi/pycom/","title":"Pycom Modules","keywords":"","body":"Pycom Modules\nThese modules are specific to the Pycom devices and may have slightly different implementations to other variations of MicroPython (i.e. for Non-Pycom devices). Modules include those which support access to underlying hardware, e.g. I2C, SPI, WLAN, Bluetooth, etc.\n"},"firmwareapi/pycom/machine/":{"url":"firmwareapi/pycom/machine/","title":"machine","keywords":"","body":"machine\nThe machine module contains specific functions related to the board.\nQuick Usage Example\nimport machine\n\nhelp(machine) # display all members from the machine module\nmachine.freq() # get the CPU frequency\nmachine.unique_id() # return the 6-byte unique id of the board (the LoPy's WiFi MAC address)\n\nReset Functions\nmachine.reset()\nResets the device in a manner similar to pushing the external RESET button.\nmachine.reset_cause()\nGet the reset cause. See constants for the possible return values.\nInterrupt Functions\nmachine.disable_irq()\nDisable interrupt requests. Returns and integer representing the previous IRQ state. This return value can be passed to enable_irq to restore the IRQ to its original state.\nmachine.enable_irq([state])\nEnable interrupt requests. The most common use of this function is to pass the value returned by disable_irq to exit a critical section. Another options is to enable all interrupts which can be achieved by calling the function with no parameters.\nPower Functions\nmachine.freq()\nReturns CPU frequency in hertz.\nmachine.idle()\nGates the clock to the CPU, useful to reduce power consumption at any time during short or long periods. Peripherals continue working and execution resumes as soon as any interrupt is triggered (on many ports this includes system timer interrupt occurring at regular intervals on the order of millisecond).\nmachine.deepsleep([time_ms])\nStops the CPU and all peripherals, including the networking interfaces (except for LTE). Execution is resumed from the main script, just as with a reset. If a value in milliseconds is given then the device will wake up after that period of time, otherwise it will remain in deep sleep until the reset button is pressed.\nThe products with LTE connectivity (FiPy, GPy, G01), require the LTE radio to be disabled separately via the LTE class before entering deepsleep. This is required due to the LTE radio being powered independently and allowing use cases which require the system to be taken out from deepsleep by an event from the LTE network (data or SMS received for instance).\nmachine.pin_deepsleep_wakeup(pins, mode, enable_pull)\nConfigure pins to wake up from deep sleep mode. The pins which have this capability are: P2, P3, P4, P6, P8 to P10 and P13 to P23.\nThe arguments are:\n\npins a list or tuple containing the GPIO to setup for deepsleep wakeup.\nmode selects the way the configure GPIOs can wake up the module. The possible values are: machine.WAKEUP_ALL_LOW and machine.WAKEUP_ANY_HIGH.\nenable_pull if set to True keeps the pull up or pull down resistors enabled during deep sleep. If this variable is set to True, then ULP or capacitive touch wakeup cannot be used in combination with GPIO wakeup.\n\nmachine.wake_reason()\nGet the wake reason. See constants for the possible return values. Returns a tuple of the form: (wake_reason, gpio_list). When the wakeup reason is either GPIO or touch pad, then the second element of the tuple is a list with GPIOs that generated the wakeup.\nmachine.remaining_sleep_time()\nReturns the remaining timer duration (in milliseconds) if the ESP32 is woken up from deep sleep by something other than the timer. For example, if you set the timer for 30 seconds (30000 ms) and it wakes up after 10 seconds then this function will return 20000.\nMiscellaneous Functions\nmachine.main(filename)\nSet the filename of the main script to run after boot.py is finished. If this function is not called then the default file main.py will be executed.\nIt only makes sense to call this function from within boot.py.\nmachine.rng()\nReturn a 24-bit software generated random number.\nmachine.unique_id()\nReturns a byte string with a unique identifier of a board/SoC. It will vary from a board/SoC instance to another, if underlying hardware allows. Length varies by hardware (so use substring of a full value if you expect a short ID). In some MicroPython ports, ID corresponds to the network MAC address.\nUse ubinascii.hexlify() to convert the byte string to hexadecimal form for ease of manipulation and use elsewhere.\n\nmachine.info()\nReturns the high water mark of the stack associated with various system tasks, in words (1 word = 4 bytes on the ESP32). If the value is zero then the task has likely overflowed its stack. If the value is close to zero then the task has come close to overflowing its stack.\nConstants\nReset Causes\nmachine.PWRON_RESET, machine.HARD_RESET, machine.WDT_RESET, machine.DEEPSLEEP_RESET, machine.SOFT_RESET, machine.BROWN_OUT_RESET\nWake Reasons\nmachine.PWRON_WAKE, machine.PIN_WAKE, machine.RTC_WAKE, machine.ULP_WAKE\nPin Wakeup Modes\nmachine.WAKEUP_ALL_LOW, machine.WAKEUP_ANY_HIGH\n"},"firmwareapi/pycom/machine/adc.html":{"url":"firmwareapi/pycom/machine/adc.html","title":"ADC","keywords":"ADC Analog ADCChannel","body":"ADC\nclass ADC – Analog to Digital Conversion\nQuick Usage Example\nimport machine\n\nadc = machine.ADC() # create an ADC object\napin = adc.channel(pin='P16') # create an analog pin on P16\nval = apin() # read an analog value\n\nConstructors\nclass machine.ADC(id=0)\nCreate an ADC object; associate a channel with a pin. For more info check the hardware section.\nMethods\nadc.init( * , bits=12)\nEnable the ADC block. This method is automatically called on object creation.\n\nBits can take values between 9 and 12 and selects the number of bits of resolution of the ADC block.\n\nadc.deinit()\nDisable the ADC block.\nadc.channel(* , pin, attn=ADC.ATTN_0DB)\nCreate an analog pin.\n\npin is a keyword-only string argument. Valid pins are P13 to P20.\nattn is the attenuation level. The supported values are: ADC.ATTN_0DB, ADC.ATTN_2_5DB, ADC.ATTN_6DB, ADC.ATTN_11DB\n\nReturns an instance of ADCChannel. Example:\n# enable an ADC channel on P16\napin = adc.channel(pin='P16')\n\nadc.vref(vref)\nIf called without any arguments, this function returns the current calibrated voltage (in millivolts) of the 1.1v reference. Otherwise it will update the calibrated value (in millivolts) of the internal 1.1v reference.\nadc.vref_to_pin(pin)\nConnects the internal 1.1v to external GPIO. It can only be connected to P22, P21 or P6. It is recommended to only use P6 on the WiPy, on other modules this pin is connected to the radio.\nConstants\n\nADC channel attenuation values: ADC.ATTN_0DB, ADC.ATTN_2_5DB, ADC.ATTN_6DB, ADC.ATTN_11DB\n\nclass ADCChannel\nRead analog values from internal/external sources. ADC channels can be connected to internal points of the MCU or to GPIO pins. ADC channels are created using the ADC.channel method.\nMethods\nadcchannel()\nFast method to read the channel value.\nadcchannel.value()\nRead the channel value.\nadcchannel.init()\n(Re)init and enable the ADC channel. This method is automatically called on object creation.\nadcchannel.deinit()\nDisable the ADC channel.\nadcchannel.voltage()\nReads the channels value and converts it into a voltage (in millivolts)\nadcchannel.value_to_voltage(value)\nConverts the provided value into a voltage (in millivolts) in the same way voltage does.\nADC pin input range is 0-1.1V. This maximum value can be increased up to 3.3V using the highest attenuation of 11dB. Do not exceed the maximum of 3.3V, to avoid damaging the device.\n\n"},"firmwareapi/pycom/machine/dac.html":{"url":"firmwareapi/pycom/machine/dac.html","title":"DAC","keywords":"","body":"DAC\nThe DAC is used to output analog values (a specific voltage) on pin P22 or pin P21. The voltage will be between 0 and 3.3V.\nQuick Usage Example\nimport machine\n\ndac = machine.DAC('P22') # create a DAC object\ndac.write(0.5) # set output to 50%\n\ndac_tone = machine.DAC('P21') # create a DAC object\ndac_tone.tone(1000, 0) # set tone output to 1kHz\n\nConstructors\nclass class machine.DAC(pin)\nCreate a DAC object, that will let you associate a channel with a pin. pin can be a string argument.\nMethods\ndac.init()\nEnable the DAC block. This method is automatically called on object creation.\ndac.deinit()\nDisable the DAC block.\ndac.write(value)\nSet the DC level for a DAC pin. value is a float argument, with values between 0 and 1.\ndac.tone(frequency, amplitude)\nSets up tone signal to the specified frequency at amplitude scale. frequency can be from 125Hz to 20kHz in steps of 122Hz. amplitude is an integer specifying the tone amplitude to write the DAC pin. Amplitude value represents:\n\n0 is 0dBV (~ 3Vpp at 600 Ohm load)\n1 is -6dBV (~1.5 Vpp), 2 is -12dBV (~0.8 Vpp)\n3 is -18dBV (~0.4 Vpp).\nThe generated signal is a sine wave with an DC offset of VDD/2.\n\n\n"},"firmwareapi/pycom/machine/i2c.html":{"url":"firmwareapi/pycom/machine/i2c.html","title":"I2C","keywords":"","body":"I2C\nI2C is a two-wire protocol for communicating between devices. At the physical level it consists of 2 wires: SCL and SDA, the clock and data lines respectively.\nI2C objects are created attached to a specific bus. They can be initialised when created, or initialised later on.\nExample using default Pins\nfrom machine import I2C\n\ni2c = I2C(0) # create on bus 0\ni2c = I2C(0, I2C.MASTER) # create and init as a master\ni2c = I2C(0, pins=('P10','P11')) # create and use non-default PIN assignments (P10=SDA, P11=SCL)\ni2c.init(I2C.MASTER, baudrate=20000) # init as a master\ni2c.deinit() # turn off the peripheral\n\nExample using non-default Pins\nfrom machine import I2C\n\ni2c = I2C(0, pins=('P10','P11')) # create and use non-default PIN assignments (P10=SDA, P11=SCL)\ni2c.init(I2C.MASTER, baudrate=20000) # init as a master\ni2c.deinit() # turn off the peripheral\n\nPrinting the i2c object gives you information about its configuration.\nA master must specify the recipient's address:\ni2c.init(I2C.MASTER)\ni2c.writeto(0x42, '123') # send 3 bytes to slave with address 0x42\ni2c.writeto(addr=0x42, b'456') # keyword for address\n\nMaster also has other methods:\ni2c.scan() # scan for slaves on the bus, returning\n # a list of valid addresses\ni2c.readfrom_mem(0x42, 2, 3) # read 3 bytes from memory of slave 0x42,\n # starting at address 2 in the slave\ni2c.writeto_mem(0x42, 2, 'abc') # write 'abc' (3 bytes) to memory of slave 0x42\n # starting at address 2 in the slave, timeout after 1 second\n\nQuick Usage Example\nfrom machine import I2C\n# configure the I2C bus\ni2c = I2C(0, I2C.MASTER, baudrate=100000)\ni2c.scan() # returns list of slave addresses\ni2c.writeto(0x42, 'hello') # send 5 bytes to slave with address 0x42\ni2c.readfrom(0x42, 5) # receive 5 bytes from slave\ni2c.readfrom_mem(0x42, 0x10, 2) # read 2 bytes from slave 0x42, slave memory 0x10\ni2c.writeto_mem(0x42, 0x10, 'xy') # write 2 bytes to slave 0x42, slave memory 0x10\n\nConstructors\nclass machine.I2C(bus, ...)\nConstruct an I2C object on the given bus. bus can only be 0, 1, 2. If the bus is not given, the default one will be selected (0). Buses 0 and 1 use the ESP32 I2C hardware peripheral while bus 2 is implemented with a bit-banged software driver.\nMethods\nGeneral Methods\ni2c.init(mode, * , baudrate=100000, pins=(SDA, SCL))\nInitialise the I2C bus with the given parameters:\n\nmode must be I2C.MASTER\nbaudrate is the SCL clock rate\npins is an optional tuple with the pins to assign to the I2C bus. The default I2C pins are P9 (SDA) and P10 (SCL)\n\ni2c.scan()\nScan all I2C addresses between 0x08 and 0x77 inclusive and return a list of those that respond. A device responds if it pulls the SDA line low after its address (including a read bit) is sent on the bus.\nStandard Bus Operations\nThe following methods implement the standard I2C master read and write operations that target a given slave device.\ni2c.readfrom(addr, nbytes)\nRead nbytes from the slave specified by addr. Returns a bytes object with the data read.\ni2c.readfrom_into(addr, buf)\nRead into buf from the slave specified by addr. The number of bytes read will be the length of buf.\nReturn value is the number of bytes read.\ni2c.writeto(addr, buf, * , stop=True)\nWrite the bytes from buf to the slave specified by addr. The argument buf can also be an integer which will be treated as a single byte. If stop is set to False then the stop condition won't be sent and the I2C operation may be continued (typically with a read transaction).\nReturn value is the number of bytes written.\nMemory Operations\nSome I2C devices act as a memory device (or set of registers) that can be read from and written to. In this case there are two addresses associated with an I2C transaction: the slave address and the memory address. The following methods are convenience functions to communicate with such devices.\ni2c.readfrom_mem(addr, memaddr, nbytes, *, addrsize=8)\nRead nbytes from the slave specified by addr starting from the memory address specified by memaddr. The addrsize argument is specified in bits and it can only take 8 or 16.\ni2c.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8)\nRead into buf from the slave specified by addr starting from the memory address specified by memaddr. The number of bytes read is the length of buf. The addrsize argument is specified in bits and it can only take 8 or 16.\nThe return value is the number of bytes read.\ni2c.writeto_mem(addr, memaddr, buf *, addrsize=8)\nWrite buf to the slave specified by addr starting from the memory address specified by memaddr. The argument buf can also be an integer which will be treated as a single byte. The addrsize argument is specified in bits and it can only take 8 or 16.\nThe return value is the number of bytes written.\nConstants\n\nI2C.MASTER: Used to initialise the bus to master mode.\n\n"},"firmwareapi/pycom/machine/pin.html":{"url":"firmwareapi/pycom/machine/pin.html","title":"Pin","keywords":"","body":"Pin\nA pin is the basic object to control I/O pins (also known as GPIO - general-purpose input/output). It has methods to set the mode of the pin (input, output, etc) and methods to get and set the digital logic level. For analog control of a pin, see the ADC class.\nQuick Usage Example\nfrom machine import Pin\n\n# initialize `P9` in gpio mode and make it an output\np_out = Pin('P9', mode=Pin.OUT)\np_out.value(1)\np_out.value(0)\np_out.toggle()\np_out(True)\n\n# make `P10` an input with the pull-up enabled\np_in = Pin('P10', mode=Pin.IN, pull=Pin.PULL_UP)\np_in() # get value, 0 or 1\n\nConstructors\nclass machine.Pin(id, ...)\nCreate a new Pin object associated with the string id. If additional arguments are given, they are used to initialise the pin. See pin.init()\nfrom machine import Pin\np = Pin('P10', mode=Pin.OUT, pull=None, alt=-1)\n\nMethods\npin.init(mode, pull, * , alt)\nInitialise the pin:\n\nmode can be one of:\nPin.IN - input pin.\nPin.OUT - output pin in push-pull mode.\nPin.OPEN_DRAIN - input or output pin in open-drain mode.\n\n\npull can be one of:\nNone - no pull up or down resistor.\nPin.PULL_UP - pull up resistor enabled.\nPin.PULL_DOWN - pull down resistor enabled.\n\n\n*\nPin value: 0 or 1\n\n\nalt is the id of the alternate function.\n\nReturns: None.\npin.id()\nGet the pin id.\npin.value([value])\nGet or set the digital logic level of the pin:\n\nWith no argument, return 0 or 1 depending on the logic level of the pin.\nWith value given, set the logic level of the pin. value can be anything that converts to a boolean. If it converts to True, the pin is set high, otherwise it is set low.\n\npin([value])\nPin objects are callable. The call method provides a (fast) shortcut to set and get the value of the pin.\nExample:\nfrom machine import Pin\npin = Pin('P12', mode=Pin.IN, pull=Pin.PULL_UP)\npin() # fast method to get the value\n\nSee pin.value() for more details.\npin.toggle()\nToggle the value of the pin.\npin.mode([mode])\nGet or set the pin mode.\npin.pull([pull])\nGet or set the pin pull.\npin.hold([hold])\nGet or set the pin hold. You can apply a hold to a pin by passing True (or clear it by passing False). When a pin is held, its value cannot be changed by using Pin.value() or Pin.toggle() until the hold is released. This Can be used to retain the pin state through a core reset and system reset triggered by watchdog time-out or Deep-sleep events. Only pins in the RTC power domain can retain their value through deep sleep or reset.\nThese are: P2, P3, P4, P6, P8, P9, P10, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23\npin.callback(trigger, handler=None, arg=None)\nSet a callback to be triggered when the input level at the pin changes.\n\ntrigger is the type of event that triggers the callback. Possible values are:\nPin.IRQ_FALLING interrupt on falling edge.\nPin.IRQ_RISING interrupt on rising edge.\nPin.IRQ_LOW_LEVEL interrupt on low level.\nPin.IRQ_HIGH_LEVEL interrupt on high level.\n\n\n\nThe values can be OR-ed together, for instance trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING\n\nhandler is the function to be called when the event happens. This function will receive one argument. Set handler to None to disable it.\narg is an optional argument to pass to the callback. If left empty or set to None, the function will receive the Pin object that triggered it.\n\nExample:\nfrom machine import Pin\n\ndef pin_handler(arg):\n print(\"got an interrupt in pin %s\" % (arg.id()))\n\np_in = Pin('P10', mode=Pin.IN, pull=Pin.PULL_UP)\np_in.callback(Pin.IRQ_FALLING | Pin.IRQ_RISING, pin_handler)\n\nFor more information on how Pycom's products handle interrupts, see here.\n\nAttributes\nclass pin.exp_board\nContains all Pin objects supported by the expansion board. Examples:\nPin.exp_board.G16\nled = Pin(Pin.exp_board.G16, mode=Pin.OUT)\nPin.exp_board.G16.id()\n\nclass pin.module\nContains all Pin objects supported by the module. Examples:\nPin.module.P9\nled = Pin(Pin.module.P9, mode=Pin.OUT)\nPin.module.P9.id()\n\nConstants\nThe following constants are used to configure the pin objects. Note that not all constants are available on all ports.\n\nSelects the pin mode: Pin.IN, Pin.OUT, Pin.OPEN_DRAIN\nEnables the pull up or pull down resistor: Pin.PULL_UP, Pin.PULL_DOWN\n\n"},"firmwareapi/pycom/machine/pwm.html":{"url":"firmwareapi/pycom/machine/pwm.html","title":"PWM","keywords":"","body":"PWM\nclass PWM – Pulse Width Modulation\nQuick Usage Example\nfrom machine import PWM\npwm = PWM(0, frequency=5000) # use PWM timer 0, with a frequency of 5KHz\n# create pwm channel on pin P12 with a duty cycle of 50%\npwm_c = pwm.channel(0, pin='P12', duty_cycle=0.5)\npwm_c.duty_cycle(0.3) # change the duty cycle to 30%\n\nConstructors\nclass machine.PWM(timer, frequency)\nCreate a PWM object. This sets up the timer to oscillate at the specified frequency. timer is an integer from 0 to 3. frequency is an integer from 1 Hz to 78 KHz (this values can change in future upgrades).\nMethods\npwm.channel(id, pin * , duty_cycle=0.5)\nConnect a PWM channel to a pin, setting the initial duty cycle. id is an integer from 0 to 7. pin is a string argument. duty_cycle is a keyword-only float argument, with values between 0 and 1. Returns an instance of PWMChannel.\nclass PWMChannel — PWM channel\nMethods\npwmchannel.duty_cycle(value)\nSet the duty cycle for a PWM channel. value is a float argument, with values between 0 and 1.\n"},"firmwareapi/pycom/machine/rtc.html":{"url":"firmwareapi/pycom/machine/rtc.html","title":"RTC","keywords":"","body":"RTC\nThe RTC is used to keep track of the date and time.\nQuick Usage Example\nfrom machine import RTC\n\nrtc = RTC()\nrtc.init((2014, 5, 1, 4, 13, 0, 0, 0))\nprint(rtc.now())\n\nConstructors\nclass machine.RTC(id=0, ...)\nCreate an RTC object. See init for parameters of initialisation.\n# id of the RTC may be set if multiple are connected. Defaults to id = 0.\nrtc = RTC(id=0)\n\nMethods\nrtc.init(datetime=None, source=RTC.INTERNAL_RC)\nInitialise the RTC. The arguments are:\n\ndatetime when passed it sets the current time. It is a tuple of the form: (year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])\nsource selects the oscillator that drives the RTC. The options are RTC.INTERNAL_RC and RTC.XTAL_32KHZ\n\nFor example:\n# for 2nd of February 2017 at 10:30am (TZ 0)\nrtc.init((2017, 2, 28, 10, 30, 0, 0, 0))\n\ntzinfo is ignored by this method. Use time.timezone to achieve similar results.\n\nrtc.now()\nGet get the current datetime tuple:\n# returns datetime tuple\nrtc.now()\n\nrtc.ntp_sync(server, * , update_period=3600)\nSet up automatic fetch and update the time using NTP (SNTP).\n\nserver is the URL of the NTP server. Can be set to None to disable the periodic updates.\nupdate_period is the number of seconds between updates. Shortest period is 15 seconds.\n\nCan be used like:\nrtc.ntp_sync(\"pool.ntp.org\") # this is an example. You can select a more specific server according to your geographical location\n\nrtc.synced()\nReturns True if the last ntp_sync has been completed, False otherwise:\nrtc.synced()\n\nConstants\n\nClock source: RTC.INTERNAL_RC, RTC.XTAL_32KHZ\n\n"},"firmwareapi/pycom/machine/spi.html":{"url":"firmwareapi/pycom/machine/spi.html","title":"SPI","keywords":"","body":"SPI\nSPI is a serial protocol that is driven by a master. At the physical level there are 3 lines: SCK, MOSI, MISO.\nSee usage model of I2C; SPI is very similar. Main difference is parameters to init the SPI bus:\nfrom machine import SPI\nspi = SPI(0, mode=SPI.MASTER, baudrate=1000000, polarity=0, phase=0, firstbit=SPI.MSB)\n\nOnly required parameter is mode, must be SPI.MASTER. Polarity can be 0 or 1, and is the level the idle clock line sits at. Phase can be 0 or 1 to sample data on the first or second clock edge respectively.\nQuick Usage Example\nfrom machine import SPI\n\n# configure the SPI master @ 2MHz\n# this uses the SPI default pins for CLK, MOSI and MISO (``P10``, ``P11`` and ``P14``)\nspi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=0, phase=0)\nspi.write(bytes([0x01, 0x02, 0x03, 0x04, 0x05])) # send 5 bytes on the bus\nspi.read(5) # receive 5 bytes on the bus\nrbuf = bytearray(5)\nspi.write_readinto(bytes([0x01, 0x02, 0x03, 0x04, 0x05]), rbuf) # send a receive 5 bytes\n\nQuick Usage Example using non-default pins\nfrom machine import SPI\n\n# configure the SPI master @ 2MHz\n# this uses the SPI non-default pins for CLK, MOSI and MISO (``P19``, ``P20`` and ``P21``)\nspi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=0, phase=0, pins=('P19','P20','P21'))\nspi.write(bytes([0x01, 0x02, 0x03, 0x04, 0x05])) # send 5 bytes on the bus\nspi.read(5) # receive 5 bytes on the bus\nrbuf = bytearray(5)\nspi.write_readinto(bytes([0x01, 0x02, 0x03, 0x04, 0x05]), rbuf) # send a receive 5 bytes\n\nConstructors\nclass machine.SPI(id, ...)\nConstruct an SPI object on the given bus. id can be only 0. With no additional parameters, the SPI object is created but not initialised (it has the settings from the last initialisation of the bus, if any). If extra arguments are given, the bus is initialised. See init for parameters of initialisation.\nMethods\nspi.init(mode, baudrate=1000000, * , polarity=0, phase=0, bits=8, firstbit=SPI.MSB, pins=(CLK, MOSI, MISO))\nInitialise the SPI bus with the given parameters:\n\nmode must be SPI.MASTER.\nbaudrate is the SCK clock rate.\npolarity can be 0 or 1, and is the level the idle clock line sits at.\nphase can be 0 or 1 to sample data on the first or second clock edge respectively.\nbits is the width of each transfer, accepted values are 8, 16 and 32.\nfirstbit can be SPI.MSB or SPI.LSB.\npins is an optional tuple with the pins to assign to the SPI bus. If the pins argument is not given the default pins will be selected (P10 as CLK,P11 as MOSI and P14 as MISO). If pins is passed as None then no pin assignment will be made.\n\nspi.deinit()\nTurn off the SPI bus.\nspi.write(buf)\nWrite the data contained in buf. Returns the number of bytes written.\nspi.read(nbytes, * , write=0x00)\nRead the nbytes while writing the data specified by write. Returns the bytes read.\nspi.readinto(buf, * , write=0x00)\nRead into the buffer specified by buf while writing the data specified by write. Return the number of bytes read.\nspi.write_readinto(write_buf, read_buf)\nWrite from write_buf and read into read_buf. Both buffers must have the same length. Returns the number of bytes written\nConstants\n\nFor initialising the SPI bus to master: SPI.MASTER\nSet the first bit to be the most significant bit: SPI.MSB\nSet the first bit to be the least significant bit: SPI.LSB\n\n"},"firmwareapi/pycom/machine/uart.html":{"url":"firmwareapi/pycom/machine/uart.html","title":"UART","keywords":"","body":"UART\nUART implements the standard UART/USART duplex serial communications protocol. At the physical level it consists of 2 lines: RXD and TXD. The unit of communication is a character (not to be confused with a string character) which can be 5, 6, 7 or 8 bits wide.\nUART objects can be created and initialised using:\nfrom machine import UART\n\nuart = UART(1, 9600) # init with given baudrate\nuart.init(9600, bits=8, parity=None, stop=1) # init with given parameters\n\nBits can be 5, 6, 7, 8. Parity can be None, UART.EVEN or UART.ODD. Stop can be 1, 1.5 or 2.\nA UART object acts like a stream object therefore reading and writing is done using the standard stream methods:\nuart.read(10) # read 10 characters, returns a bytes object\nuart.readall() # read all available characters\nuart.readline() # read a line\nuart.readinto(buf) # read and store into the given buffer\nuart.write('abc') # write the 3 characters\n\nTo check if there is anything to be read, use:\nuart.any() # returns the number of characters available for reading\n\nQuick Usage Example\nfrom machine import UART\n# this uses the UART_1 default pins for TXD and RXD (``P3`` and ``P4``)\nuart = UART(1, baudrate=9600)\nuart.write('hello')\nuart.read(5) # read up to 5 bytes\n\nQuick Usage Example using non-default pins (TXD/RXD only)\nfrom machine import UART\n# this uses the UART_1 non-default pins for TXD and RXD (``P20`` and ``P21``)\nuart = UART(1, baudrate=9600, pins=('P20','P21'))\nuart.write('hello')\nuart.read(5) # read up to 5 bytes\n\nQuick Usage Example using non-default pins (TXD/RXD and flow control)\nfrom machine import UART\n# this uses the UART_1 non-default pins for TXD, RXD, RTS and CTS (``P20``, ``P21``, ``P22``and ``P23``)\nuart = UART(1, baudrate=9600, pins=('P20', 'P21', 'P22', 'P23'))\nuart.write('hello')\nuart.read(5) # read up to 5 bytes\n\nConstructors\nclass machine.UART(bus, ...)\nConstruct a UART object on the given bus. bus can be 0, 1 or 2. If the bus is not given, the default one will be selected (0) or the selection will be made based on the given pins.\nOn the GPy/FiPy UART2 is unavailable because it is used to communicate with the cellular radio.\n\nMethods\nuart.init(baudrate=9600, bits=8, parity=None, stop=1, * , timeout_chars=2, pins=(TXD, RXD, RTS, CTS))\nInitialise the UART bus with the given parameters:\n\nbaudrate is the clock rate.\nbits is the number of bits per character. Can be 5, 6, 7 or 8.\nparity is the parity, None, UART.EVEN or UART.ODD.\nstop is the number of stop bits, 1 or 2.\ntimeout_chars Rx timeout defined in number of characters. The value given here will be multiplied by the time a characters takes to be transmitted at the configured baudrate.\npins is a 4 or 2 item list indicating the TXD, RXD, RTS and CTS pins (in that order). Any of the pins can be None if one wants the UART to operate with limited functionality. If the RTS pin is given the the RX pin must be given as well. The same applies to CTS. When no pins are given, then the default set of TXD (P1) and RXD (P0) pins is taken, and hardware flow control will be disabled. If pins=None, no pin assignment will be made.\n\nuart.deinit()\nTurn off the UART bus.\nuart.any()\nReturn the number of characters available for reading.\nuart.read([nbytes])\nRead characters. If nbytes is specified then read at most that many bytes.\nReturn value: a bytes object containing the bytes read in. Returns None on timeout.\nuart.readall()\nRead as much data as possible.\nReturn value: a bytes object or None on timeout.\nuart.readinto(buf[, nbytes])\nRead bytes into the buf. If nbytes is specified then read at most that many bytes. Otherwise, read at most len(buf) bytes.\nReturn value: number of bytes read and stored into buf or None on timeout.\nuart.readline()\nRead a line, ending in a newline character. If such a line exists, return is immediate. If the timeout elapses, all available data is returned regardless of whether a newline exists.\nReturn value: the line read or None on timeout if no data is available.\nuart.write(buf)\nWrite the buffer of bytes to the bus.\nReturn value: number of bytes written or None on timeout.\nuart.sendbreak()\nSend a break condition on the bus. This drives the bus low for a duration of 13 bits. Return value: None.\nuart.wait_tx_done(timeout_ms)\nWaits at most timeout_ms for the last Tx transaction to complete. Returns True if all data has been sent and the TX buffer has no data in it, otherwise returns False.\nConstants\n\nParity types (along with None): UART.EVEN, UART.ODD\nIRQ trigger sources: UART.RX_ANY\n\n"},"firmwareapi/pycom/machine/wdt.html":{"url":"firmwareapi/pycom/machine/wdt.html","title":"WDT","keywords":"","body":"WDT\nThe WDT is used to restart the system when the application crashes and ends up into a non recoverable state. After enabling, the application must \"feed\" the watchdog periodically to prevent it from expiring and resetting the system.\nQuick Usage Example\nfrom machine import WDT\nwdt = WDT(timeout=2000) # enable it with a timeout of 2 seconds\nwdt.feed()\n\nConstructors\nclass machine.WDT(id=0, timeout)\nCreate a WDT object and start it. The id can only be 0. See the init method for the parameters of initialisation.\nMethods\nwdt.init(timeout)\nInitialises the watchdog timer. The timeout must be given in milliseconds. Once it is running the WDT cannot be stopped but the timeout can be re-configured at any point in time.\nwdt.feed()\nFeed the WDT to prevent it from resetting the system. The application should place this call in a sensible place ensuring that the WDT is only fed after verifying that everything is functioning correctly.\n"},"firmwareapi/pycom/machine/timer.html":{"url":"firmwareapi/pycom/machine/timer.html","title":"Timer","keywords":"","body":"Timer\nclass Timer – Measure Time and Set Alarms\nTimers can be used for a great variety of tasks, like measuring time spans or being notified that a specific interval has elapsed.\nThese two concepts are grouped into two different subclasses:\nChrono: used to measure time spans. Alarm: to get interrupted after a specific interval.\nYou can create as many of these objects as needed.\n\nConstructors\nclass Timer.Chrono()\nCreate a chronometer object.\nclass Timer.Alarm(handler=None, s, * , ms, us, arg=None, periodic=False)\nCreate an Alarm object.\n\nhandler: will be called after the interval has elapsed. If set to None, the alarm will be disabled after creation.\narg: an optional argument can be passed to the callback handler function. If None is specified, the function will receive the object that triggered the alarm.\ns, ms, us: the interval can be specified in seconds (float), miliseconds (integer) or microseconds (integer). Only one at a time can be specified.\nperiodic: an alarm can be set to trigger repeatedly by setting this parameter to True.\n\nMethods\nTimer.sleep_us()\nDelay for a given number of microseconds, should be positive or 0 (for speed, the condition is not enforced). Internally it uses the same timer as the other elements of the Timer class. It compensates for the calling overhead, so for example, 100us should be really close to 100us. For times bigger than 10,000us it releases the GIL to let other threads run, so exactitude is not guaranteed for delays longer than that.\nclass Chrono\nCan be used to measure time spans.\nMethods\nchrono.start()\nStart the chronometer.\nchrono.stop()\nStop the chronometer.\nchrono.reset()\nReset the time count to 0.\nchrono.read()\nGet the elapsed time in seconds.\nchrono.read_ms()\nGet the elapsed time in milliseconds.\nchrono.read_us()\nGet the elapsed time in microseconds.\nExample:\nfrom machine import Timer\nimport time\n\nchrono = Timer.Chrono()\n\nchrono.start()\ntime.sleep(1.25) # simulate the first lap took 1.25 seconds\nlap = chrono.read() # read elapsed time without stopping\ntime.sleep(1.5)\nchrono.stop()\ntotal = chrono.read()\n\nprint()\nprint(\"\\nthe racer took %f seconds to finish the race\" % total)\nprint(\" %f seconds in the first lap\" % lap)\nprint(\" %f seconds in the last lap\" % (total - lap))\nclass Alarm – get interrupted after a specific interval\n\nclass Alarm\nUsed to get interrupted after a specific interval.\nMethods\nalarm.callback(handler, * , arg=None)\nSpecify a callback handler for the alarm. If set to None, the alarm will be disabled.\nAn optional argument arg can be passed to the callback handler function. If None is specified, the function will receive the object that triggered the alarm.\nalarm.cancel()\nDisables the alarm.\nExample:\nfrom machine import Timer\n\nclass Clock:\n\n def __init__(self):\n self.seconds = 0\n self.__alarm = Timer.Alarm(self._seconds_handler, 1, periodic=True)\n\n def _seconds_handler(self, alarm):\n self.seconds += 1\n print(\"%02d seconds have passed\" % self.seconds)\n if self.seconds == 10:\n alarm.cancel() # stop counting after 10 seconds\n\nclock = Clock()\n\nFor more information on how Pycom's products handle interrupts, see notes.\n\n"},"firmwareapi/pycom/machine/sd.html":{"url":"firmwareapi/pycom/machine/sd.html","title":"SD","keywords":"","body":"SD\nThe SD card class allows to configure and enable the memory card module of your Pycom module and automatically mount it as /sd as part of the file system. There is a single pin combination that can be used for the SD card, and the current implementation only works in 1-bit mode. The pin connections are as follows:\nP8: DAT0, P23: SCLK and P4: CMD (no external pull-up resistors are needed)\nIf you have one of the Pycom expansion boards, then simply insert the card into the micro SD socket and run your script.\nMake sure your SD card is formatted either as FAT16 or FAT32.\n\nQuick Example Usage:\nfrom machine import SD\nimport os\n\nsd = SD()\nos.mount(sd, '/sd')\n\n# check the content\nos.listdir('/sd')\n\n# try some standard file operations\nf = open('/sd/test.txt', 'w')\nf.write('Testing SD card write operations')\nf.close()\nf = open('/sd/test.txt', 'r')\nf.readall()\nf.close()\n\nConstructors\nclass machine.SD(id, ...)\nCreate a SD card object. See sd.init() for parameters if initialisation.\nMethods\nsd.init(id=0)\nEnable the SD card.\nsd.deinit()\nDisable the SD card.\nPlease note that the SD card library currently supports FAT16/32 formatted SD cards up to 32 GB. Future firmware updates will increase compatibility with additional formats and sizes.\n\n"},"firmwareapi/pycom/machine/can.html":{"url":"firmwareapi/pycom/machine/can.html","title":"CAN","keywords":"","body":"CAN\nThe CAN class supports the full CAN 2.0 specification with standard and extended frames, as well as acceptance filtering.\nThe ESP32 has a built-in CAN controller, but the transceiver needs to be added externally. A recommended device is the SN65HVD230.\nQuick Usage Example\nfrom machine import CAN\n\ncan = CAN(mode=CAN.NORMAL, baudrate=500000, pins=('P22', 'P23'))\ncan.send(id=12, data=bytes([1, 2, 3, 4, 5, 6, 7, 8]))\ncan.recv()\n\nConstructors\nclass machine.CAN(bus=0, ...)\nCreate an CAN object. See init for parameters of initialisation.:\n# only 1 CAN peripheral is available, so the bus must always be 0\ncan = CAN(0, mode=CAN.NORMAL, baudrate=500000, pins=('P22', 'P23')) # pin order is Tx, Rx\n\nMethods\ncan.init(mode=CAN.NORMAL, baudrate=500000, *, frame_format=CAN.FORMAT_STD, rx_queue_len=128, pins=('P22', 'P23'))\nInitialize the CAN controller. The arguments are:\n\nmode can take either CAN.NORMAL or CAN.SILENT. Silent mode is useful for sniffing the bus.\nbaudrate sets up the bus speed. Acceptable values are between 1 and 1000000.\nframe_format defines the frame format to be accepted by the receiver. Useful for filtering frames based on the identifier length. Can tale either CAN.FORMAT_STD, CAN.FORMAT_EXT, CAN.FORMAT_BOTH. If CAN.FORMAT_STD is selected, extended frames won't be received and vice-versa.\nrx_queue_len defines the number of messages than can be queued by the receiver. Due to CAN being a high traffic bus, large values are recommended (>= 128), otherwise messages will be dropped specially when no filtering is applied.\npins selects the Tx and Rx pins (in that order).\n\ncan.deinit()\nDisables the CAN bus.\ncan.send(id, * , data=None, rtr=False, extended=False)\nSend a CAN frame on the bus\n\nid is the identifier of the message.\ndata can take up to 8 bytes. It must be left empty is the message to be sent is a remote request (rtr=True).\nrtr set it to false to send a remote request.\nextnted specifies if the message identifier width should be 11bit (standard) or 29bit (extended).\n\nCan be used like:\ncan.send(id=0x0020, data=bytes([0x01, 0x02, 0x03, 0x04, 0x05]), extended=True) # sends 5 bytes with an extended identifier\n\ncan.send(id=0x010, data=bytes([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08])) # sends 8 bytes with an standard identifier\n\ncan.send(id=0x012, rtr=True) # sends a remote request for message id=0x12\n\ncan.recv(timeout=0)\nGet a message from the receive queue, and optionally specify a timeout value in s (can be a floating point value e.g. 0.2). This function returns None if no messages available. If a message is present, it will be returned as a named tuple with the following form:\n(id, data, rtr, extended)\n>>> can.recv()\n(id=0x012, data=b'123', rtr=False, extended=False)\n\ncan.soft_filter(mode, filter_list)\nSpecify a software filter accepting only the messages that pass the filter test.\nThere are 3 possible filter modes:\n\nCAN.FILTER_LIST allows to pass the list of IDs that should be accepted.\nCAN.FILTER_RANGE allows to pass a list or tuple of ID ranges that should be accepted.\nCAN.FILTER_MASK allows to pass a list of tuples of the form: (filter, mask).\n\nWith software filters all messages in the bus are received by the CAN controller but only the matching ones are passed to the RX queue. This means that the queue won't be filled up with non relevant messages, but the interrupt overhead will remain as normal. The filter_list can contain up to 32 elements.\nFor example:\ncan.soft_filter(CAN.FILTER_LIST, [0x100, 0x200, 0x300, 0x400]) # only accept identifiers from 0x100, 0x200, 0x300 and 0x400\n\ncan.soft_filter(CAN.FILTER_RANGE, [(0x001, 0x010), (0x020, 0x030), (0x040, 0x050)]) # only accept identifiers from 0x001 to 0x010, from 0x020 to 0x030 and from 0x040 to 0x050.\n\ncan.soft_filter(CAN.FILTER_MASK, [(0x100, 0x7FF), (0x200, 0x7FC)]) # more of the classic Filter and Mask method.\n\ncan.soft_filter(None) # disable soft filters, all messages are accepted\n\ncan.callback(trigger, handler=None, arg=None)\nSet a callback to be triggered when any of this 3 events are present:\n\ntrigger is the type of event that triggers the callback. Possible values are:\nCAN.RX_FRAME interrupt whenever a new frame is received.\nCAN.RX_FIFO_NOT_EMPTY interrupt when a frame is received on an empty FIFO.\nCAN.RX_FIFO_OVERRUN interrupt when a message is received and the FIFO is full.\n\n\n\nThe values can be OR-ed together, for instance trigger=CAN.RX_FRAME | CAN.RX_FIFO_OVERRUN\n\nhandler is the function to be called when the event happens. This function will receive one argument. Set handler to None to disable the callback.\narg is an optional argument to pass to the callback. If left empty or set to None, the function will receive the CAN object that triggered it.\n\nIt can be used like this:\nfrom machine import CAN\n\ncan = CAN(mode=CAN.NORMAL, baudrate=500000, pins=('P22', 'P23'))\n\ndef can_cb(can_o):\n print('CAN Rx:', can_o.recv())\n\ncan.callback(handler=can_cb, trigger=CAN.RX_FRAME)\n\ncan.events()\nThis method returns a value with bits sets (if any) indicating the events that have occurred in the bus. Please note that by calling this function the internal events registry is cleared automatically, therefore calling it immediately for a second time will most likely return a value of 0.\nConstants\nCAN.NORMAL, CAN.SILENT, CAN.FORMAT_STD, CAN.FORMAT_EXT, CAN.FORMAT_BOTH, CAN.RX_FRAME, CAN.RX_FIFO_NOT_EMPTY, CAN.RX_FIFO_OVERRUN, CAN.FILTER_LIST, CAN.FILTER_RANGE, CAN.FILTER_MASK\n"},"firmwareapi/pycom/machine/rmt.html":{"url":"firmwareapi/pycom/machine/rmt.html","title":"RMT","keywords":"RMT Remote Remote Controller Pulse","body":"RMT\nThe RMT (Remote Control) module is primarily designed to send and receive infrared remote control signals that use on-off-keying of a carrier frequency, but due to its design it can be used to generate various types of signals.\nQuick Usage Example: sending\nimport machine\n\n# create a RMT object for transmission\nrmt = machine.RMT(channel=3, gpio=\"P20\", tx_idle_level=0)\n# create series of bits to send \ndata = (1,0,1,0,1,0,1,0,1)\n# define duration of the bits, time unit depends on the selected RMT channel \nduration = 10000\n# send the signal \nrmt.send_pulses(duration, data)\n\nQuick Usage Example: receiving\nimport machine\n# create a RMT object\nrmt = machine.RMT(channel=3)\n# Configure RTM for receiving\nrmt.init(gpio=\"P20\", rx_idle_threshold=12000) \n# wait for any number of pulses until one longer than rx_idle_threshold \ndata = rmt.recv_pulses()\n\nConstructors\nclass machine.RMT(channel,...)\nConstruct an RMT object on the given channel. channel can be 2-7. With no additional parameters, the RMT object is created but not initialised. If extra arguments are given, the RMT is initialised for transmission or reception. See init for parameters of initialisation. The resolution which a pulse can be sent/received depends on the selected channel:\n\n\n\nChannel\nResolution\nMaximum Pulse Width\n\n\n\n\n0\nUsed by on-board LED\n\n\n\n1\nUsed by pycom.pulses_get()\n\n\n\n2\n100nS\n3.2768 ms\n\n\n3\n100nS\n3.2768 ms\n\n\n4\n1000nS\n32.768 ms\n\n\n5\n1000nS\n32.768 ms\n\n\n6\n3125nS\n102.4 ms\n\n\n7\n3125nS\n102.4 ms\n\n\n\nMethods\nrmt.init(gpio, rx_idle_threshold, rx_filter_threshold, tx_idle_level, tx_carrier)\nInitialise the RMT peripheral with the given parameters:\n\ngpio is the GPIO Pin to use.\nrx_idle_threshold is the maximum duration of a valid pulse. The represented time unit (resolution) depends on the selected channel, value can be 0-65535.\nrx_filter_threshold is the minimum duration of a valid pulse. The represented time unit (resolution) depends on the selected channel, value can be 0-31.\ntx_idle_level is the output signal's level after the transmission is finished, can be RMT.HIGH or RMT.LOW.\ntx_carrier is the modulation of the pulses to send.\n\nEither rx_idle_threshold or tx_idle_level must be defined, both cannot be given at the same time because a channel can be configured in RX or TX mode only. rx_filter_threshold is not mandatory parameter. If not given then all pulses are accepted with duration less than rx_idle_threshold. tx_carrier is not mandatory parameters. If not given no modulation is used on the sent pulses.\nThe tx_carrier parameter is a tuple with the following structure:\n\ncarrier_freq_hz is the carrier's frequency in Hz.\ncarrier_duty_percent is the duty percent of the carrier's signal, can be 0%-100%.\ncarrier_level is the level of the pulse to modulate, can be RMT.HIGH or RMT.LOW.\n\nrmt.deinit()\nDeinitialise the RMT object.\nIf an RMT object needs to be reconfigured from RX/TX to TX/RX, then either first deinit() must be called or the init() again with the desired configuration.\n\nrmt.pulses_get(pulses, timeout)\nReads in pulses from the GPIO pin.\n\npulses if not specified, this function will keep reading pulses until the\nrx_idle_threshold is exceeded. If it is specified this function will return\nthe exactly that number of pulses, ignoring anything shorter than\nrx_filter_threshold or longer than rx_idle_threshold.\n\ntimeout is specified, this function will return if the first pulse does\nnot occur within timeout microseconds. If not specified, it will wait\nindefinitely.\n\n\nReturn value: Tuple of items with the following structure: (level, duration):\n\nlevel represents the level of the received bit/pulse, can be 0 or 1.\nduration represents the duration of the received pulse, the time unit (resolution) depends on the selected channel.\n\nMaximum of 128 pulses can be received in a row without receiving \"idle\" signal. If the incoming pulse sequence contains more than 128 pulses the rest is dropped and the receiver waits for another sequence of pulses. The pulses_get function can be called to receive more than 128 pulses, however the above mentioned limitation should be kept in mind when evaluating the received data.\n\nrmt.pulses_send(duration, data, start_level)\nGenerates pulses as defined by the parameters below\n\nduration represents the duration of the pulses to be sent,\nthe time unit (resolution) depends on the selected channel.\n\ndata Tuple that represents the sequence of pulses to be sent, must be\ncomposed of 0 or 1 elements.\n\nstart_level defines the state (HIGH/LOW) of the first pulse given by\nduration if data is not given.\n\n\ndata must be a tuple and duration can be a tuple or a single number, with data being optional. In the case that only duration is provided, it must be a tuple and you must also provide start_level which will dictate the level of the first duration, the signal level then toggles between each duration value. If data is provided and duration is a single number, each pulse in data will have have an equal length as set by duration. If data and duration are provided as tuples, they must be of the same number of elements, with each pulse lasting its matching duration.\nConstants\n\nDefine the level of the pulse: RMT.LOW, RMT.HIGH\n\n"},"firmwareapi/pycom/network/":{"url":"firmwareapi/pycom/network/","title":"network","keywords":"","body":"network\nThis module provides access to network drivers and routing configuration. Network drivers for specific hardware are available within this module and are used to configure specific hardware network interfaces.\n"},"firmwareapi/pycom/network/wlan.html":{"url":"firmwareapi/pycom/network/wlan.html","title":"WLAN","keywords":"","body":"WLAN\nThis class provides a driver for the WiFi network processor in the module. Example usage:\nimport network\nimport time\n# setup as a station\nwlan = network.WLAN(mode=network.WLAN.STA)\nwlan.connect('your-ssid', auth=(network.WLAN.WPA2, 'your-key'))\nwhile not wlan.isconnected():\n time.sleep_ms(50)\nprint(wlan.ifconfig())\n\n# now use socket as usual\n\nQuick Usage Example\nimport machine\nfrom network import WLAN\n\n# configure the WLAN subsystem in station mode (the default is AP)\nwlan = WLAN(mode=WLAN.STA)\n# go for fixed IP settings (IP, Subnet, Gateway, DNS)\nwlan.ifconfig(config=('192.168.0.107', '255.255.255.0', '192.168.0.1', '192.168.0.1'))\nwlan.scan() # scan for available networks\nwlan.connect(ssid='mynetwork', auth=(WLAN.WPA2, 'my_network_key'))\nwhile not wlan.isconnected():\n pass\nprint(wlan.ifconfig())\n\nConstructors\nclass network.WLAN(id=0, ...)\nCreate a WLAN object, and optionally configure it. See init for params of configuration.\nThe WLAN constructor is special in the sense that if no arguments besides the id are given, it will return the already existing WLAN instance without re-configuring it. This is because WLAN is a system feature of the WiPy. If the already existing instance is not initialised it will do the same as the other constructors an will initialise it with default values.\n\nMethods\nwlan.init(mode, * , ssid=None, auth=None, channel=1, antenna=None, power_save=False, hidden=False)\nSet or get the WiFi network processor configuration.\nArguments are:\n\nmode can be either WLAN.STA, WLAN.AP, or WLAN.STA_AP.\nssid is a string with the SSID name. Only needed when mode is WLAN.AP.\nauth is a tuple with (sec, key). Security can be None, WLAN.WEP, WLAN.WPA, or WLAN.WPA2. The key is a string with the network password.\nIf sec is WLAN.WEP the key must be a string representing hexadecimal values (e.g. ABC1DE45BF). Only needed when mode is WLAN.AP.\n\n\nchannel a number in the range 1-11. Only needed when mode is WLAN.AP.\nantenna selects between the internal and the external antenna. Can be either WLAN.INT_ANT, WLAN.EXT_ANT. With our development boards it defaults to using the internal antenna, but in the case of an OEM module, the antenna pin (P12) is not used, so it's free to be\nused for other things.\n\npower_save enables or disables power save functions in STA mode.\n\nhidden only valid in WLAN.AP mode to create an access point with a hidden SSID when set to True.\n\nFor example, you can do:\n# create and configure as an access point\nwlan.init(mode=WLAN.AP, ssid='wipy-wlan', auth=(WLAN.WPA2,'www.wipy.io'), channel=7, antenna=WLAN.INT_ANT)\n\nor\n# configure as an station\nwlan.init(mode=WLAN.STA)\n\nTo use an external antenna, set P12 as output pin.\nPin('P12', mode=Pin.OUT)(True)\n\n\nwlan.deinit()\nDisables the WiFi radio.\nwlan.connect(ssid, * , auth=None, bssid=None, timeout=None, ca_certs=None, keyfile=None, certfile=None, identity=None)\nConnect to a wifi access point using the given SSID, and other security parameters.\n\nauth is a tuple with (sec, key). Security can be None, WLAN.WEP, WLAN.WPA, WLAN.WPA2 or WLAN.WPA2_ENT. The key is a string with the network password.\nIf sec is WLAN.WEP the key must be a string representing hexadecimal values (e.g. ABC1DE45BF).\nIf sec is WLAN.WPA2_ENT then the auth tuple can have either 3 elements: (sec, username, password), or just 1: (sec,). When passing the 3 element tuple, thekeyfile and certifle arguments must not be given.\n\n\nbssid is the MAC address of the AP to connect to. Useful when there are several APs with the same SSID.\ntimeout is the maximum time in milliseconds to wait for the connection to succeed.\nca_certs is the path to the CA certificate. This argument is not mandatory.\nkeyfile is the path to the client key. Only used if username and password are not part of the auth tuple.\ncertfile is the path to the client certificate. Only used if username and password are not part of the auth tuple.\nidentity is only used in case of WLAN.WPA2_ENT security. Needed by the server.\n\nThe ESP32 only handles certificates with pkcs8 format (but not the \"Traditional SSLeay RSAPrivateKey\" format). The private key should be RSA coded with 2048 bits at maximum.\n\nwlan.scan()\nPerforms a network scan and returns a list of named tuples with (ssid, bssid, sec, channel, rssi). Note that channel is always None since this info is not provided by the WiPy.\nwlan.disconnect()\nDisconnect from the WiFi access point.\nwlan.isconnected()\nIn case of STA mode, returns True if connected to a WiFi access point and has a valid IP address. In AP mode returns True when a station is connected, False otherwise.\nwlan.ifconfig(id=0, config=['dhcp' or configtuple])\nWhen id is 0, the configuration will be get/set on the Station interface. When id is 1 the configuration will be done for the AP interface.\nWith no parameters given returns a 4-tuple of (ip, subnet_mask, gateway, DNS_server).\nIf dhcp is passed as a parameter then the DHCP client is enabled and the IP params are negotiated with the AP.\nIf the 4-tuple config is given then a static IP is configured. For instance:\nwlan.ifconfig(config=('192.168.0.4', '255.255.255.0', '192.168.0.1', '8.8.8.8'))\n\nwlan.mode([mode])\nGet or set the WLAN mode.\nwlan.ssid([ssid])\nGet or set the SSID when in AP mode.\nwlan.auth([auth])\nGet or set the authentication type when in AP mode.\nwlan.channel([channel])\nGet or set the channel (only applicable in AP mode).\nwlan.antenna([antenna])\nGet or set the antenna type (external or internal).\nTo use an external antenna, set P12 as output pin.\nPin('P12', mode=Pin.OUT)(True)\n\n\nwlan.mac()\nGet a 6-byte long bytes object with the WiFI MAC address.\nConstants\n\nWLAN mode: WLAN.STA, WLAN.AP, WLAN.STA_AP\nWLAN network security: WLAN.WEP, WLAN.WPA, WLAN.WPA2, WLAN.WPA2_ENT\nAntenna type: WLAN.INT_ANT, WLAN.EXT_ANT\n\n"},"firmwareapi/pycom/network/server.html":{"url":"firmwareapi/pycom/network/server.html","title":"Server","keywords":"","body":"Server\nThe Server class controls the behaviour and the configuration of the FTP and telnet services running on the Pycom device. Any changes performed using this class' methods will affect both.\nExample:\nimport network\nserver = network.Server()\nserver.deinit() # disable the server\n# enable the server again with new settings\nserver.init(login=('user', 'password'), timeout=600)\n\nQuick Usage Example\nfrom network import Server\n\n# init with new user, password and seconds timeout\nserver = Server(login=('user', 'password'), timeout=60)\nserver.timeout(300) # change the timeout\nserver.timeout() # get the timeout\nserver.isrunning() # check whether the server is running or not\n\nConstructors\nclass network.Server(id, ...)\nCreate a server instance, see init for parameters of initialisation.\nMethods\nserver.init(* , login=('micro', 'python'), timeout=300)\nInit (and effectively start the server). Optionally a new user, password and timeout (in seconds) can be passed.\nserver.deinit()\nStop the server.\nserver.timeout([timeout_in_seconds])\nGet or set the server timeout.\nserver.isrunning()\nReturns True if the server is running (connected or accepting connections), False otherwise.\n"},"firmwareapi/pycom/network/bluetooth/":{"url":"firmwareapi/pycom/network/bluetooth/","title":"Bluetooth","keywords":"","body":"Bluetooth\nThis class provides a driver for the Bluetooth radio in the module. Currently, only basic BLE functionality is available.\nQuick Usage Example\nfrom network import Bluetooth\nimport time\nbt = Bluetooth()\nbt.start_scan(-1)\n\nwhile True:\n adv = bt.get_adv()\n if adv and bt.resolve_adv_data(adv.data, Bluetooth.ADV_NAME_CMPL) == 'Heart Rate':\n try:\n conn = bt.connect(adv.mac)\n services = conn.services()\n for service in services:\n time.sleep(0.050)\n if type(service.uuid()) == bytes:\n print('Reading chars from service = {}'.format(service.uuid()))\n else:\n print('Reading chars from service = %x' % service.uuid())\n chars = service.characteristics()\n for char in chars:\n if (char.properties() & Bluetooth.PROP_READ):\n print('char {} value = {}'.format(char.uuid(), char.read()))\n conn.disconnect()\n break\n except:\n print(\"Error while connecting or reading from the BLE device\")\n break\n else:\n time.sleep(0.050)\n\nBluetooth Low Energy (BLE)\nBluetooth low energy (BLE) is a subset of classic Bluetooth, designed for easy connecting and communicating between devices (in particular mobile platforms). BLE uses a methodology known as Generic Access Profile (GAP) to control connections and advertising.\nGAP allows for devices to take various roles but generic flow works with devices that are either a Server (low power, resource constrained, sending small payloads of data) or a Client device (commonly a mobile device, PC or Pycom Device with large resources and processing power). Pycom devices can act as both a Client and a Server.\nConstructors\nclass network.Bluetooth(id=0, ...)\nCreate a Bluetooth object, and optionally configure it. See init for params of configuration.\nExample:\nfrom network import Bluetooth\nbluetooth = Bluetooth()\n\nMethods\nbluetooth.init(id=0, mode=Bluetooth.BLE, antenna=None)\n\nid Only one Bluetooth peripheral available so must always be 0\nmode currently the only supported mode is Bluetooth.BLE\nantenna selects between the internal and the external antenna. Can be eitherBluetooth.INT_ANT, Bluetooth.EXT_ANT.\nWith our development boards it defaults to using the internal antenna, but in the case of an OEM module, the antenna pin (P12) is not used, so it's free to be used for other things.\n\n\nInitialises and enables the Bluetooth radio in BLE mode.\nTo use an external antenna, set P12 as output pin.\nPin('P12', mode=Pin.OUT)(True)\n\n\nbluetooth.deinit()\nDisables the Bluetooth radio.\nbluetooth.start_scan(timeout)\nStarts performing a scan listening for BLE devices sending advertisements. This function always returns immediately, the scanning will be performed on the background. The return value is None. After starting the scan the function get_adv() can be used to retrieve the advertisements messages from the FIFO. The internal FIFO has space to cache 16 advertisements.\nThe arguments are:\n\ntimeout specifies the amount of time in seconds to scan for advertisements, cannot be zero. If timeout is > 0, then the BLE radio will listen for advertisements until the specified value in seconds elapses. If timeout \n\nExamples:\nbluetooth.start_scan(10) # starts scanning and stop after 10 seconds\nbluetooth.start_scan(-1) # starts scanning indefinitely until bluetooth.stop_scan() is called\n\nbluetooth.stop_scan()\nStops an ongoing scanning process. Returns None.\nbluetooth.isscanning()\nReturns True if a Bluetooth scan is in progress. False otherwise.\nbluetooth.get_adv()\nGets an named tuple with the advertisement data received during the scanning. The tuple has the following structure: (mac, addr_type, adv_type, rssi, data)\n\nmac is the 6-byte ling mac address of the device that sent the advertisement.\naddr_type is the address type. See the constants section below for more details.\nadv_type is the advertisement type received. See the constants section below fro more details.\nrssi is signed integer with the signal strength of the advertisement.\ndata contains the complete 31 bytes of the advertisement message. In order to parse the data and get the specific types, the method resolve_adv_data() can be used.\n\nExample for getting mac address of an advertiser:\nimport ubinascii\n\nbluetooth = Bluetooth()\nbluetooth.start_scan(20) # scan for 20 seconds\n\nadv = bluetooth.get_adv() #\nubinascii.hexlify(adv.mac) # convert hexadecimal to ascii\n\nbluetooth.get_advertisements()\nSame as the get_adv() method, but this one returns a list with all the advertisements received.\nbluetooth.resolve_adv_data(data, data_type)\nParses the advertisement data and returns the requested data_type if present. If the data type is not present, the function returns None.\nArguments:\n\ndata is the bytes object with the complete advertisement data.\ndata_type is the data type to resolve from from the advertisement data. See constants section below for details.\n\nExample:\nimport ubinascii\nfrom network import Bluetooth\nbluetooth = Bluetooth()\n\nbluetooth.start_scan(20)\nwhile bluetooth.isscanning():\n adv = bluetooth.get_adv()\n if adv:\n # try to get the complete name\n print(bluetooth.resolve_adv_data(adv.data, Bluetooth.ADV_NAME_CMPL))\n\n mfg_data = bluetooth.resolve_adv_data(adv.data, Bluetooth.ADV_MANUFACTURER_DATA)\n\n if mfg_data:\n # try to get the manufacturer data (Apple's iBeacon data is sent here)\n print(ubinascii.hexlify(mfg_data))\n\nbluetooth.connect(mac_addr)\nOpens a BLE connection with the device specified by the mac_addr argument. This function blocks until the connection succeeds or fails. If the connections succeeds it returns a object of type GATTCConnection.\nConnections are initiated by the central device. There is a maximum of 4 simultaneous connections.\nbluetooth.connect('112233eeddff') # mac address is accepted as a string\n\nbluetooth.callback(trigger=None, handler=None, arg=None)\nCreates a callback that will be executed when any of the triggers occurs. The arguments are:\n\ntrigger can be either Bluetooth.NEW_ADV_EVENT, Bluetooth.CLIENT_CONNECTED, or Bluetooth.CLIENT_DISCONNECTED\nhandler is the function that will be executed when the callback is triggered.\narg is the argument that gets passed to the callback. If nothing is given the bluetooth object itself is used.\n\nAn example of how this may be used can be seen in the bluetooth.events() method.\nbluetooth.events()\nReturns a value with bit flags identifying the events that have occurred since the last call. Calling this function clears the events.\nExample of usage:\nfrom network import Bluetooth\n\nbluetooth = Bluetooth()\nbluetooth.set_advertisement(name='LoPy', service_uuid=b'1234567890123456')\n\ndef conn_cb (bt_o):\n events = bt_o.events() # this method returns the flags and clears the internal registry\n if events & Bluetooth.CLIENT_CONNECTED:\n print(\"Client connected\")\n elif events & Bluetooth.CLIENT_DISCONNECTED:\n print(\"Client disconnected\")\n\nbluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=conn_cb)\n\nbluetooth.advertise(True)\n\nbluetooth.set_advertisement(* , name=None, manufacturer_data=None, service_data=None, service_uuid=None)\nConfigure the data to be sent while advertising. If left with the default of None the data won't be part of the advertisement message.\nThe arguments are:\n\nname is the string name to be shown on advertisements.\nmanufacturer_data manufacturer data to be advertised (hint: use it for iBeacons).\nservice_data service data to be advertised.\nservice_uuid uuid of the service to be advertised.\n\nExample:\nbluetooth.set_advertisement(name=\"advert\", manufacturer_data=\"lopy_v1\")\n\nbluetooth.advertise([Enable])\nStart or stop sending advertisements. The set_advertisement() method must have been called prior to this one.\nbluetooth.service(uuid, * , isprimary=True, nbr_chars=1, start=True)\nCreate a new service on the internal GATT server. Returns a object of type BluetoothServerService.\nThe arguments are:\n\nuuid is the UUID of the service. Can take an integer or a 16 byte long string or bytes object.\nisprimary selects if the service is a primary one. Takes a bool value.\nnbr_chars specifies the number of characteristics that the service will contain.\nstart if True the service is started immediately.\n\nbluetooth.service('abc123')\n\nbluetooth.disconnect_client()\nCloses the BLE connection with the client.\nConstants\n\nBluetooth mode: Bluetooth.BLE\nAdvertisement type: Bluetooth.CONN_ADV, Bluetooth.CONN_DIR_ADV, Bluetooth.DISC_ADV, Bluetooth.NON_CONN_ADV, Bluetooth.SCAN_RSP\nAddress type: Bluetooth.PUBLIC_ADDR, Bluetooth.RANDOM_ADDR, Bluetooth.PUBLIC_RPA_ADDR, Bluetooth.RANDOM_RPA_ADDR\nAdvertisement data type: Bluetooth.ADV_FLAG, Bluetooth.ADV_16SRV_PART, Bluetooth.ADV_T16SRV_CMPL, Bluetooth.ADV_32SRV_PART, Bluetooth.ADV_32SRV_CMPL, Bluetooth.ADV_128SRV_PART, Bluetooth.ADV_128SRV_CMPL, Bluetooth.ADV_NAME_SHORT, Bluetooth.ADV_NAME_CMPL, Bluetooth.ADV_TX_PWR, Bluetooth.ADV_DEV_CLASS, Bluetooth.ADV_SERVICE_DATA, Bluetooth.ADV_APPEARANCE, Bluetooth.ADV_ADV_INT, Bluetooth.ADV_32SERVICE_DATA, Bluetooth.ADV_128SERVICE_DATA, Bluetooth.ADV_MANUFACTURER_DATA\nCharacteristic properties (bit values that can be combined): Bluetooth.PROP_BROADCAST, Bluetooth.PROP_READ, Bluetooth.PROP_WRITE_NR, Bluetooth.PROP_WRITE, Bluetooth.PROP_NOTIFY, Bluetooth.PROP_INDICATE, Bluetooth.PROP_AUTH, Bluetooth.PROP_EXT_PROP\nCharacteristic callback events: Bluetooth.CHAR_READ_EVENT, Bluetooth.CHAR_WRITE_EVENT, Bluetooth.NEW_ADV_EVENT, Bluetooth.CLIENT_CONNECTED, Bluetooth.CLIENT_DISCONNECTED, Bluetooth.CHAR_NOTIFY_EVENT\nAntenna type: Bluetooth.INT_ANT, Bluetooth.EXT_ANT\n\n"},"firmwareapi/pycom/network/bluetooth/gatt.html":{"url":"firmwareapi/pycom/network/bluetooth/gatt.html","title":"GATT","keywords":"","body":"GATT\nGATT stands for the Generic Attribute Profile and it defines the way that two Bluetooth Low Energy devices communicate between each other using concepts called Services and Characteristics. GATT uses a data protocol known as the Attribute Protocol (ATT), which is used to store/manage Services, Characteristics and related data in a lookup table.\nGATT comes into use once a connection is established between two devices, meaning that the device will have already gone through the advertising process managed by GAP. It's important to remember that this connection is exclusive; i.e. that only one client is connected to one server at a time. This means that the client will stop advertising once a connection has been made. This remains the case, until the connection is broken or disconnected.\nThe GATT Server, which holds the ATT lookup data and service and characteristic definitions, and the GATT Client (the phone/tablet), which sends requests to this server.\n"},"firmwareapi/pycom/network/bluetooth/gattcconnection.html":{"url":"firmwareapi/pycom/network/bluetooth/gattcconnection.html","title":"GATTCConnection","keywords":"","body":"GATTCConnection\nThe GATT Client is the device that requests data from the server, otherwise known as the master device (commonly this might be a phone/tablet/PC). All transactions are initiated by the master, which receives a response from the slave.\nMethods\nconnection.disconnect()\nCloses the BLE connection. Returns None.\nconnection.isconnected()\nReturns True if the connection is still open. False otherwise.\nExample:\nfrom network import Bluetooth\nimport ubinascii\nbluetooth = Bluetooth()\n\n# scan until we can connect to any BLE device around\nbluetooth.start_scan(-1)\nadv = None\nwhile True:\n adv = bluetooth.get_adv()\n if adv:\n try:\n bluetooth.connect(adv.mac)\n except:\n # start scanning again\n bluetooth.start_scan(-1)\n continue\n break\nprint(\"Connected to device with addr = {}\".format(ubinascii.hexlify(adv.mac)))\n\nconnection.services()\nPerforms a service search on the connected BLE peripheral (server) a returns a list containing objects of the class GATTCService if the search succeeds.\nExample:\n# assuming that a BLE connection is already open\nservices = connection.services()\nprint(services)\nfor service in services:\n print(service.uuid())\n\n"},"firmwareapi/pycom/network/bluetooth/gattccservice.html":{"url":"firmwareapi/pycom/network/bluetooth/gattccservice.html","title":"GATTCService","keywords":"","body":"GATTCService\nServices are used to categorise data up into specific chunks of data known as characteristics. A service may have multiple characteristics, and each service has a unique numeric ID called a UUID.\nThe following class allows control over Client services.\nMethods\nservice.isprimary()\nReturns True if the service is a primary one. False otherwise.\nservice.uuid()\nReturns the UUID of the service. In the case of 16-bit or 32-bit long UUIDs, the value returned is an integer, but for 128-bit long UUIDs the value returned is a bytes object.\nservice.instance()\nReturns the instance ID of the service.\nservice.characteristics()\nPerforms a get characteristics request on the connected BLE peripheral a returns a list containing objects of the class GATTCCharacteristic if the request succeeds.\n"},"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html":{"url":"firmwareapi/pycom/network/bluetooth/gattccharacteristic.html","title":"GATTCCharacteristic","keywords":"","body":"GATTCCharacteristic\nThe smallest concept in GATT is the Characteristic, which encapsulates a single data point (though it may contain an array of related data, such as X/Y/Z values from a 3-axis accelerometer, longitude and latitude from a GPS, etc.).\nThe following class allows you to manage characteristics from a Client.\nMethods\ncharacteristic.uuid()\nReturns the UUID of the service. In the case of 16-bit or 32-bit long UUIDs, the value returned is an integer, but for 128-bit long UUIDs the value returned is a bytes object.\ncharacteristic.instance()\nReturns the instance ID of the service.\ncharacteristic.properties()\nReturns an integer indicating the properties of the characteristic. Properties are represented by bit values that can be OR-ed together. See the constants section for more details.\ncharacteristic.read()\nRead the value of the characteristic, sending a request to the GATT server. Returns a bytes object representing the characteristic value.\ncharacteristic.value()\nReturns the locally stored value of the characteristic without sending a read request to the GATT server. If the characteristic value hasn't been read from the GATT server yet, the value returned will be 0.\ncharacteristic.write(value)\nWrites the given value on the characteristic. For now it only accepts bytes object representing the value to be written.\ncharacteristic.write(b'x0f')\n\ncharacteristic.callback(trigger=None, handler=None, arg=None)\nThis method allows to register for notifications on the characteristic.\n\ntrigger can must be Bluetooth.CHAR_NOTIFY_EVENT.\nhandler is the function that will be executed when the callback is triggered.\narg is the argument that gets passed to the callback. If nothing is given, the characteristic object that owns the callback will be used.\n\n"},"firmwareapi/pycom/network/bluetooth/gattsservice.html":{"url":"firmwareapi/pycom/network/bluetooth/gattsservice.html","title":"GATTSService","keywords":"","body":"GATTSService\nThe GATT Server allows the device to act as a peripheral and hold its own ATT lookup data, server & characteristic definitions. In this mode, the device acts as a slave and a master must initiate a request.\nServices are used to categorise data up into specific chunks of data known as characteristics. A service may have multiple characteristics, and each service has a unique numeric ID called a UUID.\nThe following class allows control over Server services.\nMethods\nservice.start()\nStarts the service if not already started.\nservice.stop()\nStops the service if previously started.\nservice.characteristic(uuid, * , permissions, properties, value)\nCreates a new characteristic on the service. Returns an object of the class GATTSCharacteristic. The arguments are:\n\nuuid is the UUID of the service. Can take an integer or a 16 byte long string or bytes object.\npermissions configures the permissions of the characteristic. Takes an integer with a combination of the flags.\nproperties sets the properties. Takes an integer with an OR-ed combination of the flags.\nvalue sets the initial value. Can take an integer, a string or a bytes object.\n\nservice.characteristic('temp', value=25)\n\n"},"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html":{"url":"firmwareapi/pycom/network/bluetooth/gattscharacteristic.html","title":"GATTSCharacteristic","keywords":"","body":"GATTSCharacteristic\nThe smallest concept in GATT is the Characteristic, which encapsulates a single data point (though it may contain an array of related data, such as X/Y/Z values from a 3-axis accelerometer, longitude and latitude from a GPS, etc.).\nThe following class allows you to manage Server characteristics.\nMethods\ncharacteristic.value([value])\nGets or sets the value of the characteristic. Can take an integer, a string or a bytes object.\ncharacteristic.value(123) # set characteristic value to an integer with the value 123\ncharacteristic.value() # get characteristic value\n\ncharacteristic.callback(trigger=None, handler=None, arg=None)\nCreates a callback that will be executed when any of the triggers occurs. The arguments are:\n\ntrigger can be either Bluetooth.CHAR_READ_EVENT or Bluetooth.CHAR_WRITE_EVENT.\nhandler is the function that will be executed when the callback is triggered.\narg is the argument that gets passed to the callback. If nothing is given, the characteristic object that owns the callback will be used.\n\nAn example of how this could be implemented can be seen in the characteristic.events() section.\ncharacteristic.events()\nReturns a value with bit flags identifying the events that have occurred since the last call. Calling this function clears the events.\nAn example of advertising and creating services on the device:\nfrom network import Bluetooth\n\nbluetooth = Bluetooth()\nbluetooth.set_advertisement(name='LoPy', service_uuid=b'1234567890123456')\n\ndef conn_cb (bt_o):\n events = bt_o.events()\n if events & Bluetooth.CLIENT_CONNECTED:\n print(\"Client connected\")\n elif events & Bluetooth.CLIENT_DISCONNECTED:\n print(\"Client disconnected\")\n\nbluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=conn_cb)\n\nbluetooth.advertise(True)\n\nsrv1 = bluetooth.service(uuid=b'1234567890123456', isprimary=True)\n\nchr1 = srv1.characteristic(uuid=b'ab34567890123456', value=5)\n\nchar1_read_counter = 0\ndef char1_cb_handler(chr):\n global char1_read_counter\n char1_read_counter += 1\n\n events = chr.events()\n if events & Bluetooth.CHAR_WRITE_EVENT:\n print(\"Write request with value = {}\".format(chr.value()))\n else:\n if char1_read_counter 0xF1:\n return char2_read_counter\n\nchar2_cb = chr2.callback(trigger=Bluetooth.CHAR_READ_EVENT, handler=char2_cb_handler)\n\n"},"firmwareapi/pycom/network/lora.html":{"url":"firmwareapi/pycom/network/lora.html","title":"LoRa","keywords":"","body":"LoRa\nThis class provides a LoRaWAN 1.0.2 compliant driver for the LoRa network processor in the LoPy and FiPy. Below is an example demonstrating LoRaWAN Activation by Personalisation usage:\nfrom network import LoRa\nimport socket\nimport ubinascii\nimport struct\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\n# create an ABP authentication params\ndev_addr = struct.unpack(\">l\", binascii.unhexlify('00000005'))[0]\nnwk_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\napp_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\n\n# join a network using ABP (Activation By Personalisation)\nlora.join(activation=LoRa.ABP, auth=(dev_addr, nwk_swkey, app_swkey))\n\n# create a LoRa socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\n# set the LoRaWAN data rate\ns.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)\n\n# make the socket non-blocking\ns.setblocking(False)\n\n# send some data\ns.send(bytes([0x01, 0x02, 0x03]))\n\n# get any data received...\ndata = s.recv(64)\nprint(data)\n\nPlease ensure that there is an antenna connected to your device before sending/receiving LoRa messages as improper use (e.g. without an antenna), may damage the device.\n\nAdditional Examples\nFor various other complete LoRa examples, check here for additional examples.\nConstructors\nclass network.LoRa(id=0, ...)\nCreate and configure a LoRa object. See init for params of configuration.\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\nMethods\nlora.init(mode, * ,region=LoRa.EU868, frequency=868000000, tx_power=14, bandwidth=LoRa.BW_125KHZ, sf=7, preamble=8, coding_rate=LoRa.CODING_4_5, power_mode=LoRa.ALWAYS_ON, tx_iq=False, rx_iq=False, adr=False, public=True, tx_retries=1, device_class=LoRa.CLASS_A)\nThis method is used to set the LoRa subsystem configuration and to specific raw LoRa or LoRaWAN.\nThe arguments are:\n\nmode can be either LoRa.LORA or LoRa.LORAWAN.\nregion can take the following values: LoRa.AS923, LoRa.AU915, LoRa.EU868 or LoRa.US915. If not provided this will default to LoRaEU868. If they are not specified, this will also set appropriate defaults for frequency and tx_power.\nfrequency accepts values between 863000000 and 870000000 in the 868 band, or between 902000000 and 928000000 in the 915 band.\ntx_power is the transmit power in dBm. It accepts between 2 and 14 for the 868 band, and between 5 and 20 in the 915 band.\nbandwidth is the channel bandwidth in KHz. In the 868 band the accepted values are LoRa.BW_125KHZ and LoRa.BW_250KHZ. In the 915 band the accepted values are LoRa.BW_125KHZ and LoRa.BW_500KHZ.\nsf sets the desired spreading factor. Accepts values between 7 and 12.\npreamble configures the number of pre-amble symbols. The default value is 8.\ncoding_rate can take the following values: LoRa.CODING_4_5, LoRa.CODING_4_6, LoRa.CODING_4_7 or LoRa.CODING_4_8.\npower_mode can be either LoRa.ALWAYS_ON, LoRa.TX_ONLY or LoRa.SLEEP. In ALWAYS_ON mode, the radio is always listening for incoming - packets whenever a transmission is not taking place. In TX_ONLY the radio goes to sleep as soon as the transmission completes. In SLEEP mode the radio is sent to sleep permanently and won't accept any commands until the power mode is changed.\ntx_iq enables TX IQ inversion.\nrx_iq enables RX IQ inversion.\nadr enables Adaptive Data Rate.\npublic selects between the public and private sync word.\ntx_retries sets the number of TX retries in LoRa.LORAWAN mode.\ndevice_class sets the LoRaWAN device class. Can be either LoRa.CLASS_A or LoRa.CLASS_C.\n\nIn LoRa.LORAWAN mode, only adr, public, tx_retries and device_class are used. All the other params will be ignored as they are handled by the LoRaWAN stack directly. On the other hand, in LoRa.LORA mode from those 4 arguments, only the public one is important in order to program the sync word. In LoRa.LORA mode adr, tx_retries and device_class are ignored since they are only relevant to the LoRaWAN stack.\n\nFor example, you can do:\n# initialize in raw LoRa mode\nlora.init(mode=LoRa.LORA, tx_power=14, sf=12)\n\nor\n# initialize in LoRaWAN mode\nlora.init(mode=LoRa.LORAWAN)\n\nlora.join(activation, auth, * ,timeout=None, dr=None)\nJoin a LoRaWAN network. Internally the stack will automatically retry every 15 seconds until a Join Accept message is received.\nThe parameters are:\n\nactivation: can be either LoRa.OTAA or LoRa.ABP.\nauth: is a tuple with the authentication data.\ntimeout: is the maximum time in milliseconds to wait for the Join Accept message to be received. If no timeout (or zero) is given, the call returns immediately and the status of the join request can be checked with lora.has_joined().\ndr: is an optional value to specify the initial data rate for the Join Request. Possible values are 0 to 5 for EU868, or 0 to 4 for US915.\n\nIn the case of LoRa.OTAA the authentication tuple is: (dev_eui, app_eui, app_key) where dev_eui is optional. If it is not provided the LoRa MAC will be used. Therefore, you can do OTAA in 2 different ways:\nlora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0) # the device MAC address is used as DEV_EUI\n\nor\nlora.join(activation=LoRa.OTAA, auth=(dev_eui, app_eui, app_key), timeout=0) # a custom DEV_EUI is specified\n\nExample:\nfrom network import LoRa\nimport socket\nimport time\nimport ubinascii\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\n# create an OTAA authentication parameters\napp_eui = ubinascii.unhexlify('ADA4DAE3AC12676B')\napp_key = ubinascii.unhexlify('11B0282A189B75B0B4D2D8C7FA38548B')\n\n# join a network using OTAA (Over the Air Activation)\nlora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)\n\n# wait until the module has joined the network\nwhile not lora.has_joined():\n time.sleep(2.5)\n print('Not yet joined...')\n\nIn the case of LoRa.ABP the authentication tuple is: (dev_addr, nwk_swkey, app_swkey). Example:\nfrom network import LoRa\nimport socket\nimport ubinascii\nimport struct\n\n# Initialise LoRa in LORAWAN mode.\n# Please pick the region that matches where you are using the device:\n# Asia = LoRa.AS923\n# Australia = LoRa.AU915\n# Europe = LoRa.EU868\n# United States = LoRa.US915\nlora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)\n\n# create an ABP authentication params\ndev_addr = struct.unpack(\">l\", ubinascii.unhexlify('00000005'))[0]\nnwk_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\napp_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')\n\n# join a network using ABP (Activation By Personalisation)\nlora.join(activation=LoRa.ABP, auth=(dev_addr, nwk_swkey, app_swkey))\n\nlora.bandwidth([bandwidth])\nGet or set the bandwidth in raw LoRa mode (LoRa.LORA). Can be either LoRa.BW_125KHZ (0), LoRa.BW_250KHZ (1) or LoRa.BW_500KHZ (2):\n# get raw LoRa Bandwidth\nlora.bandwidth()\n\n# set raw LoRa Bandwidth\nlora.bandwidth(LoRa.BW_125KHZ)\n\nlora.frequency([frequency])\nGet or set the frequency in raw LoRa mode (LoRa.LORA). The allowed range is between 863000000 and 870000000 Hz for the 868 MHz band version or between 902000000 and 928000000 Hz for the 915 MHz band version.\n# get raw LoRa Frequency\nlora.frequency()\n\n# set raw LoRa Frequency\nlora.frequency(868000000)\n\nlora.coding_rate([coding_rate])\nGet or set the coding rate in raw LoRa mode (LoRa.LORA). The allowed values are: LoRa.CODING_4_5 (1), LoRa.CODING_4_6 (2), LoRa.CODING_4_7 (3) and LoRa.CODING_4_8 (4).\n# get raw LoRa Coding Rate\nlora.coding_rate()\n\n# set raw LoRa Coding Rate\nlora.coding_rate(LoRa.CODING_4_5)\n\nlora.preamble([preamble])\nGet or set the number of preamble symbols in raw LoRa mode (LoRa.LORA):\n# get raw LoRa preamble symbols\nlora.preamble()\n\n# set raw LoRa preamble symbols\nlora.preamble(LoRa.CODING_4_5)\n\nlora.sf([sf])\nGet or set the spreading factor value in raw LoRa mode (LoRa.LORA). The minimum value is 7 and the maximum is 12:\n# get raw LoRa spread factor value\nlora.sf()\n\n# set raw LoRa spread factor value\nlora.sf(7)\n\nlora.power_mode([power_mode])\nGet or set the power mode in raw LoRa mode (LoRa.LORA). The accepted values are: LoRa.ALWAYS_ON, LoRa.TX_ONLY, and LoRa.SLEEP:\nlora.stats()\nReturn a named tuple with useful information from the last received LoRa or LoRaWAN packet. The named tuple has the following form:\n(rx_timestamp, rssi, snr, sftx, sfrx, tx_trials, tx_power, tx_time_on_air, tx_counter, tx_frequency)\nExample:\nlora.stats()\n\nWhere:\n\nrx_timestamp is an internal timestamp of the last received packet with microseconds precision.\nrssi holds the received signal strength in dBm.\nsnr contains the signal to noise ratio id dB (as a single precision float).\nsfrx tells the data rate (in the case of LORAWAN mode) or the spreading factor (in the case of LORA mode) of the last packet received.\nsftx tells the data rate (in the case of LORAWAN mode) or the spreading factor (in the case of LORA mode) of the last packet transmitted.\ntx_trials is the number of tx attempts of the last transmitted packet (only relevant for LORAWAN confirmed packets).\ntx_power is the power of the last transmission (in dBm).\ntx_time_on_air is the time on air of the last transmitted packet (in ms).\ntx_counter is the number of packets transmitted.\ntx_frequency is the frequency used for the last transmission.\n\nlora.has_joined()\nReturns True if a LoRaWAN network has been joined. False otherwise.\nlora.add_channel(index, * , frequency, dr_min, dr_max)\nAdd a LoRaWAN channel on the specified index. If there's already a channel with that index it will be replaced with the new one.\nThe arguments are:\n\nindex: Index of the channel to add. Accepts values between 0 and 15 for EU and between 0 and 71 for US.\nfrequency: Centre frequency in Hz of the channel.\ndr_min: Minimum data rate of the channel (0-7).\ndr_max: Maximum data rate of the channel (0-7).\n\nExamples:\nlora.add_channel(index=0, frequency=868000000, dr_min=5, dr_max=6)\n\nlora.remove_channel(index)\nRemoves the channel from the specified index. On the 868MHz band the channels 0 to 2 cannot be removed, they can only be replaced by other channels using the lora.add_channel method. A way to remove all channels except for one is to add the same channel, 3 times on indexes 0, 1 and 2. An example can be seen below:\nlora.remove_channel()\n\nOn the 915MHz band there are no restrictions around this.\nlora.mac()\nReturns a byte object with the 8-Byte MAC address of the LoRa radio.\nlora.callback(trigger, handler=None, arg=None)\nSpecify a callback handler for the LoRa radio. The trigger types are LoRa.RX_PACKET_EVENT, LoRa.TX_PACKET_EVENT, and LoRa.TX_FAILED_EVENT\nThe LoRa.RX_PACKET_EVENT event is raised for every received packet. The LoRa.TX_PACKET_EVENT event is raised as soon as the packet transmission cycle ends, which includes the end of the receive windows (even if a downlink is received, the LoRa.TX_PACKET_EVENT will come last). In the case of non-confirmed transmissions, this will occur at the end of the receive windows, but, in the case of confirmed transmissions, this event will only be raised if the ack is received. If the ack is not received LoRa.TX_FAILED_EVENT will be raised after the number of tx_retries configured have been performed.\nAn example of how this callback functions can be seen the in method lora.events().\nlora.ischannel_free(rssi_threshold)\nThis method is used to check for radio activity on the current LoRa channel, and if the rssi of the measured activity is lower than the rssi_threshold given, the return value will be True, otherwise False. Example:\nlora.ischannel_free(-100)\n\nlora.set_battery_level(level)\nSet the battery level value that will be sent when the LoRaWAN MAC command that retrieves the battery level is received. This command is sent by the network and handled automatically by the LoRaWAN stack. The values should be according to the LoRaWAN specification:\n\n0 means that the end-device is connected to an external power source.\n1..254 specifies the battery level, 1 being at minimum and 254 being at maximum.\n255 means that the end-device was not able to measure the battery level.\n\nlora.set_battery_level(127) # 50% battery\n\nlora.events()\nThis method returns a value with bits sets (if any) indicating the events that have triggered the callback. Please note that by calling this function the internal events registry is cleared automatically, therefore calling it immediately for a second time will most likely return a value of 0.\nExample:\ndef lora_cb(lora):\n events = lora.events()\n if events & LoRa.RX_PACKET_EVENT:\n print('Lora packet received')\n if events & LoRa.TX_PACKET_EVENT:\n print('Lora packet sent')\n\nlora.callback(trigger=(LoRa.RX_PACKET_EVENT | LoRa.TX_PACKET_EVENT), handler=lora_cb)\n\nlora.nvram_save()\nSave the LoRaWAN state (joined status, network keys, packet counters, etc) in non-volatile memory in order to be able to restore the state when coming out of deepsleep or a power cycle.\nlora.nvram_save()\n\nlora.nvram_restore()\nRestore the LoRaWAN state (joined status, network keys, packet counters, etc) from non-volatile memory. State must have been previously stored with a call to nvram_save before entering deepsleep. This is useful to be able to send a LoRaWAN message immediately after coming out of deepsleep without having to join the network again. This can only be used if the current region matches the one saved.\nlora.nvram_restore()\n\nlora.nvram_erase()\nRemove the LoRaWAN state (joined status, network keys, packet counters, etc) from non-volatile memory.\nlora.nvram_erase()\n\nConstants\n\nLoRa stack mode: LoRa.LORA, LoRa.LORAWAN\nLoRaWAN join procedure: LoRa.OTAA, LoRa.ABP\nRaw LoRa power mode: LoRa.ALWAYS_ON, LoRa.TX_ONLY, LoRa.SLEEP\nRaw LoRa bandwidth: LoRa.BW_125KHZ, LoRa.BW_250KHZ, LoRa.BW_500KHZ\nRaw LoRa coding rate: LoRa.CODING_4_5, LoRa.CODING_4_6, LoRa.CODING_4_7, LoRa.CODING_4_8\nCallback trigger types (may be ORed): LoRa.RX_PACKET_EVENT, LoRa.TX_PACKET_EVENT, LoRa.TX_FAILED_EVENT\nLoRaWAN device class: LoRa.CLASS_A, LoRa.CLASS_C\nLoRaWAN regions: LoRa.AS923, LoRa.AU915, LoRa.EU868, LoRa.US915\n\nWorking with LoRa and LoRaWAN Sockets\nLoRa sockets are created in the following way:\nimport socket\ns = socket.socket(socket.AF_LORA, socket.SOCK_RAW)\n\nAnd they must be created after initialising the LoRa network card.\nLoRa sockets support the following standard methods from the socket module:\nsocket.close()\nUsage:\ns.close()\n\nsocket.bind(port_number)\nUsage:\ns.bind(1)\n\nThe bind() method is only applicable when the radio is configured in LoRa.LORAWAN mode.\n\nsocket.send(bytes)\nUsage:\ns.send(bytes([1, 2, 3]))\n\nor\ns.send('Hello')\n\nsocket.recv(bufsize)\nUsage:\ns.recv(128)\n\nsocket.recvfrom(bufsize)\nThis method is useful to know the destination port number of the message received. Returns a tuple of the form: (data, port)\nUsage:\ns.recvfrom(128)\n\nsocket.setsockopt(level, optname, value)\nSet the value of the given socket option. The needed symbolic constants are defined in the socket module (SO_* etc.). In the case of LoRa the values are always integers. Examples:\n# configuring the data rate\ns.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)\n\n# selecting non-confirmed type of messages\ns.setsockopt(socket.SOL_LORA, socket.SO_CONFIRMED, False)\n\n# selecting confirmed type of messages\ns.setsockopt(socket.SOL_LORA, socket.SO_CONFIRMED, True)\n\nSocket options are only applicable when the LoRa radio is used in LoRa.LORAWAN mode. When using the radio in LoRa.LORA mode, use the class methods to change the spreading factor, bandwidth and coding rate to the desired values.\n\nsocket.settimeout(value)\nSets the socket timeout value in seconds. Accepts floating point values.\nUsage:\ns.settimeout(5.5)\n\nsocket.setblocking(flag)\nUsage:\ns.setblocking(True)\n\n"},"firmwareapi/pycom/network/sigfox.html":{"url":"firmwareapi/pycom/network/sigfox.html","title":"Sigfox","keywords":"","body":"Sigfox\nSigfox is a Low Power Wide Area Network protocol that enables remote devices to connect using ultra-narrow band, UNB technology. The protocol is bi-directional, messages can both be sent up to and down from the Sigfox servers.\nWhen operating in RCZ2 and RCZ4 the module can only send messages on the default macro-channel (this is due to Sigfox network limitations). Therefore, the device needs to reset automatically to the default macro-channel after every 2 transmissions. However, due to FCC duty cycle limitations, there must a minimum of a 20s delay after resetting to the default macro-channel. Our API takes care of this, (and in real life applications you should not be in the need to send Sigfox messages that often), so it will wait for the necessary amount of time to make sure that the duty cycle restrictions are fulfilled.\nThis means that if you run a piece of test code like:\nfor i in range(1, 100):\n # send something\n s.send('Hello ' + str(i))\n\nThere will be a 20 second delay after every 2 packets.\n\nThis class provides a driver for the Sigfox network processor in the Sigfox enabled Pycom devices.\nQuick Usage Example\nfrom network import Sigfox\nimport socket\n\n# init Sigfox for RCZ1 (Europe)\nsigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)\n\n# create a Sigfox socket\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\n\n# make the socket blocking\ns.setblocking(True)\n\n# configure it as uplink only\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False)\n\n# send some bytes\ns.send(bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]))\n\nPlease ensure that there is an antenna connected to your device before sending/receiving Sigfox messages as in proper use (e.g. without an antenna), may damage the device.\n\nConstructors\nclass network.Sigfox(id=0, ...)\nCreate and configure a Sigfox object. See init for params of configuration. Examples:\n# configure radio for the Sigfox network, using RCZ1 (868 MHz)\nsigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)\n\n# configure radio for FSK, device to device across 912 MHz\nsigfox = Sigfox(mode=Sigfox.FSK, frequency=912000000)\n\nSigfox.FSK mode is not supported on LoPy 4 and FiPy.\n\nMethods\nsigfox.init(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1, * , frequency=None)\nSet the Sigfox radio configuration.\nThe arguments are:\n\nmode can be either Sigfox.SIGFOX or Sigfox.FSK. Sigfox.SIGFOX uses the Sigfox modulation and protocol while Sigfox.FSK allows to create point to point communication between 2 Devices using FSK modulation. Note: Sigfox.FSK mode is not supported on LoPy 4 and FiPy.\nrcz takes the following values: Sigfox.RCZ1, Sigfox.RCZ2, Sigfox.RCZ3, Sigfox.RCZ4. The rcz argument is only required if the mode is Sigfox.SIGFOX.\nfrequency sets the frequency value in FSK mode. Can take values between 863 and 928 MHz. \n\nThe SiPy comes in 2 different hardware flavours: a +14dBm Tx power version which can only work with RCZ1 and RCZ3 and a +22dBm version which works exclusively on RCZ2 and RCZ4.\n\nsigfox.mac()\nReturns a byte object with the 8-Byte MAC address of the Sigfox radio.\nsigfox.id()\nReturns a byte object with the 4-Byte bytes object with the Sigfox ID.\nsigfox.rssi()\nReturns a signed integer with indicating the signal strength value of the last received packet.\nsigfox.pac()\nReturns a byte object with the 8-Byte bytes object with the Sigfox PAC.\nTo return human-readable values you should import ubinascii and convert binary values to hexidecimal representation. For example:\nprint(ubinascii.hexlify(sigfox.mac()))\n\n\nsigfox.frequencies()\nReturns a tuple of the form: (uplink_frequency_hz, downlink_frequency_hz)\nsigfox.public_key([public])\nSets or gets the public key flag. When called passing a True value the Sigfox public key will be used to encrypt the packets. Calling it without arguments returns the state of the flag.\n# enable encrypted packets\nsigfox.public_key(True)\n\n# return state of public_key\nsigfox.public_key()\n\nConstants\n\nSigfox radio mode: sigfox.SIGFOX, sigfox.FSK .\nSIGFOX to specify usage of the Sigfox Public Network.\nFSK to specify device to device communication.\n\n\nSigfox zones: sigfox.RCZ1, sigfox.RCZ2, sigfox.RCZ3, sigfox.RCZ4\nRCZ1 to specify Europe, Oman & South Africa.\nRCZ2 for the USA, Mexico & Brazil.\nRCZ3 for Japan.\nRCZ4 for Australia, New Zealand, Singapore, Taiwan, Hong Kong, Colombia & Argentina.\n\n\n\nWorking with Sigfox Sockets\nSigfox sockets are created in the following way:\nimport socket\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\n\nAnd they must be created after initialising the Sigfox network card.\nSigfox sockets support the following standard methods from the socket module:\nsocket.close()\nUse it to close an existing socket.\nsocket.send(bytes)\nIn Sigfox mode the maximum data size is 12 bytes. In FSK the maximum is 64.\n# send a Sigfox payload of bytes\ns.send(bytes([1, 2, 3]))\n\n# send a Sigfox payload containing a string\ns.send('Hello')\n\nsocket.recv(bufsize)\nThis method can be used to receive a Sigfox downlink or FSK message.\n# size of buffer should be passed for expected payload, e.g. 64 bytes\ns.recv(64)\n\nsocket.setsockopt(level, optname, value)\nSet the value of the given socket option. The needed symbolic constants are defined in the socket module (SO_* etc.). In the case of Sigfox the values are always an integer. Examples:\n# wait for a downlink after sending the uplink packet\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, True)\n\n# make the socket uplink only\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False)\n\n# use the socket to send a Sigfox Out Of Band message\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_OOB, True)\n\n# disable Out-Of-Band to use the socket normally\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_OOB, False)\n\n# select the bit value when sending bit only packets\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_BIT, False)\n\nSending a Sigfox packet with a single bit is achieved by sending an empty string, i.e.:\nimport socket\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\n\n# send a 1 bit\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_BIT, True)\ns.send('')\nsocket.settimeout(value)\n# set timeout for the socket, e.g. 5 seconds\ns.settimeout(5.0)\nsocket.setblocking(flag)\n# specifies if socket should be blocking based upon Boolean flag.\ns.setblocking(True)\n\nIf the socket is set to blocking, your code will be wait until the socket completes sending/receiving.\nSigfox Downlink\nA Sigfox capable Pycom devices (SiPy) can both send and receive data from the Sigfox network. To receive data, a message must first be sent up to Sigfox, requesting a downlink message. This can be done by passing a True argument into the setsockopt() method.\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, True)\n\nAn example of the downlink procedure can be seen below:\n# init Sigfox for RCZ1 (Europe)\nsigfox = Sigfox(mode=Sigfox.SIGFOX, rcz=Sigfox.RCZ1)\n\n# create a Sigfox socket\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\n\n# make the socket blocking\ns.setblocking(True)\n\n# configure it as DOWNLINK specified by 'True'\ns.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, True)\n\n# send some bytes and request DOWNLINK\ns.send(bytes([1, 2, 3]))\n\n# await DOWNLINK message\ns.recv(32)\n\nSigfox FSK (Device to Device)\nTo communicate between two Sigfox capable devices, it may be used in FSK mode. Two devices are required to be set to the same frequency, both using FSK.\nSigfox.FSK mode is not supported on LoPy 4 and FiPy.\n\nDevice 1:\nsigfox = Sigfox(mode=Sigfox.FSK, frequency=868000000)\n\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\ns.setblocking(True)\n\nwhile True:\n s.send('Device-1')\n time.sleep(1)\n print(s.recv(64))\n\nDevice 2:\nsigfox = Sigfox(mode=Sigfox.FSK, frequency=868000000)\n\ns = socket.socket(socket.AF_SIGFOX, socket.SOCK_RAW)\ns.setblocking(True)\n\nwhile True:\n s.send('Device-2')\n time.sleep(1)\n print(s.recv(64))\n\nRemember to use the correct frequency for your region (868 MHz for Europe, 912 MHz for USA, etc.)\n\n"},"firmwareapi/pycom/network/lte.html":{"url":"firmwareapi/pycom/network/lte.html","title":"LTE","keywords":"","body":"LTE\nThe LTE class provides access to the LTE-M/NB-IoT modem on the GPy and FiPy. LTE-M/NB-IoT are new categories of cellular protocols developed by the 3GPP and optimised for long battery life power and longer range. These are new protocols currently in the process of being deployed by mobile networks across the world.\nThe GPy and FiPy support both new LTE-M protocols:\n\nCat-M1: also known as LTE-M defines a 1.4 MHz radio channel size and about 375 kbps of throughput. It is optimised for coverage and long battery life, outperforming 2G/GPRS, while being similar to previous LTE standards.\nCat-NB1 also known as NB-IoT, defines a 200 kHz radio channel size and around 60 kbps of uplink speed. It's optimised for ultra low throughput and specifically designed for IoT devices with a very long battery life. NB-IoT shares some features with LTE such as operating in licensed spectrum, but it's a very different protocol. It should be noted that NB-IoT has many restrictions as does not offer full IP connectivity and does not support mobility. When moving between cells, you will need to reconnect.\n\nPlease note: The GPy and FiPy only support the two protocols above and are not compatible with older LTE standards.\n\nThe Sequans modem used on Pycom's cellular enabled modules can only work in one of these modes at a time. In order to switch between the two protocols you need to flash a different firmware to the Sequans modem. Instructions for this can be found here.\n\nAT Commands\nThe AT commands for the Sequans Monarch modem on the GPy/FiPy are available in a PDF file.\nAT Commands for Sequans\nConstructors\nclass network.LTE(id=0, ...)\nCreate and configure a LTE object. See init for params of configuration.\nfrom network import LTE\nlte = LTE()\n\nMethods\nlte.init(*, carrier=None)\nThis method is used to set up the LTE subsystem. After a deinit() this method can take several seconds to return waiting for the LTE modem to start-up. Optionally specify a carrier name. The available options are: verizon, at&t, standard. standard is generic for any carrier, and it's also the option used when no arguments are given.\nlte.deinit()\nDisables LTE modem completely. This reduces the power consumption to the minimum. Call this before entering deepsleep.\nlte.attach(*, band=None)\nEnable radio functionality and attach to the LTE Cat M1 network authorised by the inserted SIM card. Optionally specify the band to scan for networks. If no band (or None) is specified, all 6 bands will be scanned. The possible values for the band are: 3, 4, 12, 13, 20 and 28.\nlte.isattached()\nReturns True if the cellular mode is attached to the network. False otherwise.\nlte.dettach()\nDetach the modem from the LTE Cat M1 and disable the radio functionality.\nlte.connect(*, cid=1)\nStart a data session and obtain and IP address. Optionally specify a CID (Connection ID) for the data session. The arguments are:\n\ncid is a Connection ID. This is carrier specific, for Verizon use cid=3. For others like Telstra it should be cid=1.\n\nFor instance, to attach and connect to Verizon:\nimport time\nfrom network import LTE\n\nlte = LTE(carrier=\"verizon\")\nlte.attach(band=13)\n\nwhile not lte.isattached():\n time.sleep(0.5)\n print('Attaching...')\n\nlte.connect(cid=3)\nwhile not lte.isconnected():\n time.sleep(0.5)\n print('Connecting...')\n\n# Now use sockets as usual...\n\nlte.isconnected()\nReturns True if there is an active LTE data session and IP address has been obtained. False otherwise.\nlte.disconnect()\nEnd the data session with the network.\nlte.send_at_cmd(cmd)\nSend an AT command directly to the modem. Returns the raw response from the modem as a string object. IMPORTANT: If a data session is active (i.e. the modem is connected), sending the AT commands requires to pause and then resume the data session. This is all done automatically, but makes the whole request take around 2.5 seconds.\nExample:\nlte.send_at_cmd('AT+CEREG?') # check for network registration manually (sames as lte.isattached())\n\nOptionally the response can be parsed for pretty printing:\ndef send_at_cmd_pretty(cmd):\n response = lte.send_at_cmd(cmd).split('\\r\\n')\n for line in response:\n print(line)\n\nsend_at_cmd_pretty('AT!=\"showphy\"') # get the PHY status\nsend_at_cmd_pretty('AT!=\"fsm\"') # get the System FSM\n\nlte.imei()\nReturns a string object with the IMEI number of the LTE modem.\nlte.iccid()\nReturns a string object with the ICCID number of the SIM card.\nlte.reset()\nPerform a hardware reset on the cellular modem. This function can take up to 5 seconds to return as it waits for the modem to shutdown and reboot.\n"},"firmwareapi/pycom/aes.html":{"url":"firmwareapi/pycom/aes.html","title":"AES","keywords":"","body":"AES\nAES (Advanced Encryption Standard) is a symmetric block cipher standardised by NIST. It has a fixed data block size of 16 bytes. Its keys can be 128, 192, or 256 bits long.\nAES is implemented using the ESP32 hardware module.\n\nQuick Usage Example\nfrom crypto import AES\nimport crypto\nkey = b'notsuchsecretkey' # 128 bit (16 bytes) key\niv = crypto.getrandbits(128) # hardware generated random IV (never reuse it)\n\ncipher = AES(key, AES.MODE_CFB, iv)\nmsg = iv + cipher.encrypt(b'Attack at dawn')\n\n# ... after properly sent the encrypted message somewhere ...\n\ncipher = AES(key, AES.MODE_CFB, msg[:16]) # on the decryption side\noriginal = cipher.decrypt(msg[16:])\nprint(original)\n\nConstructors\nclass ucrypto.AES(key, mode, IV, * , counter, segment_size)\nCreate an AES object that will let you encrypt and decrypt messages.\nThe arguments are:\n\nkey (byte string) is the secret key to use. It must be 16 (AES-128), 24 (AES-192), or 32 (AES-256) bytes long.\nmode is the chaining mode to use for encryption and decryption. Default is AES.MODE_ECB.\nIV (byte string) initialisation vector. Should be 16 bytes long. It is ignored in modes AES.MODE_ECB and AES.MODE_CRT.\ncounter (byte string) used only for AES.MODE_CTR. Should be 16 bytes long. Should not be reused.\nsegment_size is the number of bits plaintext and ciphertext are segmented in. Is only used in AES.MODE_CFB. Supported values are AES.SEGMENT_8 and AES.SEGMENT_128\n\nMethods\nucrypto.encrypt()\nEncrypt data with the key and the parameters set at initialisation.\nucrypto.decrypt()\nDecrypt data with the key and the parameters set at initialisation.\nConstants\n\nAES.MODE_ECB: Electronic Code Book. Simplest encryption mode. It does not hide data patterns well (see this article for more info)\nAES.MODE_CBC: Cipher-Block Chaining. An Initialisation Vector (IV) is required.\nAES.MODE_CFB: Cipher feedback. plaintext and ciphertext are processed in segments of segment_size bits. Works a stream cipher.\nAES.MODE_CTR: Counter mode. Each message block is associated to a counter which must be unique across all messages that get encrypted with the same key.\nAES.SEGMENT_8, AES.SEGMENT_128: Length of the segment for AES.MODE_CFB\n\nTo avoid security issues, IV should always be a random number and should never be reused to encrypt two different messages. The same applies to the counter in CTR mode. You can use crypto.getrandbits() for this purpose.\n\n"},"firmwareapi/pycom/pycom.html":{"url":"firmwareapi/pycom/pycom.html","title":"pycom","keywords":"","body":"pycom\nThe pycom module contains functions to control specific features of the Pycom devices, such as the heartbeat RGB LED.\nQuick Usage Example\nimport pycom\n\npycom.heartbeat(False) # disable the heartbeat LED\npycom.heartbeat(True) # enable the heartbeat LED\npycom.heartbeat() # get the heartbeat state\npycom.rgbled(0xff00) # make the LED light up in green color\n\nMethods\npycom.heartbeat([enable])\nGet or set the state (enabled or disabled) of the heartbeat LED. Accepts and returns boolean values (True or False).\npycom.heartbeat_on_boot([enable])\nAllows you permanently disable or enable the heartbeat LED. Once this setting is set, it will persist between reboots. Note, this only comes into effect on the next boot, it does not stop the already running heartbeat.\npycom.rgbled(color)\nSet the colour of the RGB LED. The colour is specified as 24 bit value representing red, green and blue, where the red colour is represented by the 8 most significant bits. For instance, passing the value 0x00FF00 will light up the LED in a very bright green.\npycom.nvs_set(key, value)\nSet the value of the specified key in the NVRAM memory area of the external flash. Data stored here is preserved across resets and power cycles. Value can only take 32-bit integers at the moment. Example:\nimport pycom\n\npycom.nvs_set('temp', 25)\npycom.nvs_set('count', 10)\n\npycom.nvs_get(key)\nGet the value the specified key from the NVRAM memory area of the external flash. Example:\nimport pycom\n\npulses = pycom.nvs_get('count')\n\nIf a non-existing key is given the returned value will be None.\npycom.nvs_erase(key)\nErase the given key from the NVRAM memory area.\npycom.nvs_erase_all()\nErase the entire NVRAM memory area.\npycom.wifi_on_boot([enable])\nGet or set the WiFi on boot flag. When this flag is set to True, the AP with the default SSID (lopy-wlan-xxx for example) will be enabled as part of the boot process. If the flag is set to False, the module will boot with WiFi disabled until it's enabled by the script via the WLAN class. This setting is stored in non-volatile memory which preserves it across resets and power cycles. Example:\nimport pycom\n\npycom.wifi_on_boot(True) # enable WiFi on boot\npycom.wifi_on_boot() # get the wifi on boot flag\n\npycom.wdt_on_boot([enable])\nEnables the WDT at boot time with the timeout in ms set by the function wdt_on_boot_timeout. If this flag is set, the application needs to reconfigure the WDT with a new timeout and feed it regularly to avoid a reset.\nimport pycom\n\npycom.wdt_on_boot(True) # enable WDT on boot\npycom.wdt_on_boot() # get the WDT on boot flag\n\npycom.wdt_on_boot_timeout([timeout])\nSets or gets the WDT on boot timeout in milliseconds. The minimum value is 5000 ms.\nimport pycom\n\npycom.wdt_on_boot_timeout(10000) # set the timeout to 5000ms\npycom.wdt_on_boot_timeout() # get the WDT timeout value\n\npycom.pulses_get(pin, timeout)\nReturn a list of pulses at pin. The methods scans for transitions at pin and returns a list of tuples, each telling the pin value and the duration in microseconds of that value. pin is a pin object, which must have set to INP or OPEN_DRAIN mode. The scan stops if not transitions occurs within timeout milliseconds.\nExample:\n# get the raw data from a DHT11/DHT22/AM2302 sensor\nfrom machine import Pin\nfrom pycom import pulses_get\nfrom time import sleep_ms\n\npin = Pin(\"G7\", mode=Pin.OPEN_DRAIN)\npin(0)\nsleep_ms(20)\npin(1)\ndata = pulses_get(pin, 100)\n\npycom.ota_start()\npycom.ota_write(buffer)\npycom.ota_finish()\nPerform a firmware update. These methods are internally used by a firmware update though FTP. The update starts with a call to ota_start(), followed by a series of calls to ota_write(buffer), and is terminated with ota_finish(). After reset, the new image gets active. buffer shall hold the image data to be written, in arbitrary sizes. A block size of 4096 is recommended.\nExample:\n# Firmware update by reading the image from the SD card\n#\nfrom pycom import ota_start, ota_write, ota_finish\nfrom os import mount\nfrom machine import SD\n\nBLOCKSIZE = const(4096)\nAPPIMG = \"/sd/appimg.bin\"\n\nsd = SD()\nmount(sd, '/sd')\n\nwith open(APPIMG, \"rb\") as f:\n buffer = bytearray(BLOCKSIZE)\n mv = memoryview(buffer)\n size=0\n ota_start()\n while True:\n chunk = f.readinto(buffer)\n if chunk > 0:\n ota_write(mv[:chunk])\n size += chunk\n print(\"\\r%7d \" % size, end=\"\")\n else:\n break\n ota_finish()\n\nInstead of reading the data to be written from a file, it can obviously also be received from a server using any suitable protocol, without the need to store it in the devices file system.\n"},"firmwareapi/micropython/":{"url":"firmwareapi/micropython/","title":"MicroPython Modules","keywords":"","body":"MicroPython Modules\nThe following list contains the standard Python libraries, MicroPython-specific libraries and Pycom specific modules that are available on the Pycom devices.\nThe standard Python libraries have been \"micro-ified\" to fit in with the philosophy of MicroPython. They provide the core functionality of that module and are intended to be a drop-in replacement for the standard Python library.\nSome modules are available by an u-name, and also by their non-u-name. The non-u-name can be overridden by a file of that name in your package path. For example, import json will first search for a file json.py or directory json and load that package if it's found. If nothing is found, it will fallback to loading the built-in ujson module.\n\n"},"firmwareapi/micropython/micropython.html":{"url":"firmwareapi/micropython/micropython.html","title":"micropython","keywords":"","body":"micropython\nMethods\nmicropython.alloc_emergency_exception_buf(size)\nAllocate size bytes of RAM for the emergency exception buffer (a good size is around 100 bytes). The buffer is used to create exceptions in cases when normal RAM allocation would fail (eg within an interrupt handler) and therefore give useful traceback information in these situations.\nA good way to use this function is to place it at the start of a main script (e.g. boot.py or main.py) and then the emergency exception buffer will be active for all the code following it.\nmicropython.const(expr)\nUsed to declare that the expression is a constant so that the compile can optimise it. The use of this function should be as follows:\nfrom micropython import const \n\nCONST_X = const(123)\nCONST_Y = const(2 * CONST_X + 1)\n\nConstants declared this way are still accessible as global variables from outside the module they are declared in. On the other hand, if a constant begins with an underscore then it is hidden, it is not available as a global variable, and does not take up any memory during execution.\nThis const function is recognised directly by the MicroPython parser and is provided as part of the micropython module mainly so that scripts can be written which run under both CPython and MicroPython, by following the above pattern.\nmicropython.opt_level([level])\nIf level is given then this function sets the optimisation level for subsequent compilation of scripts, and returns None. Otherwise it returns the current optimisation level.\nmicropython.mem_info([verbose])\nPrint information about currently used memory. If the verbose argument is given then extra information is printed.\nThe information that is printed is implementation dependent, but currently includes the amount of stack and heap used. In verbose mode it prints out the entire heap indicating which blocks are used and which are free.\nmicropython.qstr_info([verbose])\nPrint information about currently interned strings. If the verbose argument is given then extra information is printed.\nThe information that is printed is implementation dependent, but currently includes the number of interned strings and the amount of RAM they use. In verbose mode it prints out the names of all RAM-interned strings.\nmicropython.stack_use()\nReturn an integer representing the current amount of stack that is being used. The absolute value of this is not particularly useful, rather it should be used to compute differences in stack usage at different points.\nmicropython.heap_lock()\nmicropython.heap_unlock()\nLock or unlock the heap. When locked no memory allocation can occur and a MemoryError will be raised if any heap allocation is attempted.\nThese functions can be nested, i.e. heap_lock() can be called multiple times in a row and the lock-depth will increase, and then heap_unlock() must be called the same number of times to make the heap available again.\nmicropython.kbd_intr(chr)\nSet the character that will raise a KeyboardInterrupt exception. By default this is set to 3 during script execution, corresponding to Ctrl-C. Passing -1 to this function will disable capture of Ctrl-C, and passing 3 will restore it.\nThis function can be used to prevent the capturing of Ctrl-C on the incoming stream of characters that is usually used for the REPL, in case that stream is used for other purposes.\n"},"firmwareapi/micropython/uctypes.html":{"url":"firmwareapi/micropython/uctypes.html","title":"uctypes","keywords":"","body":"uctypes\nThis module implements \"foreign data interface\" for MicroPython. The idea behind it is similar to CPython's ctypes modules, but the actual API is different, streamlined and optimised for small size. The basic idea of the module is to define data structure layout with about the same power as the C language allows, and the access it using familiar dot-syntax to reference sub-fields.\nModule ustruct Standard Python way to access binary data structures (doesn't scale well to large and complex structures).\n\nDefining Structure Layout\nStructure layout is defined by a \"descriptor\" - a Python dictionary which encodes field names as keys and other properties required to access them as associated values. Currently, uctypes requires explicit specification of offsets for each field. Offset are given in bytes from a structure start.\nFollowing are encoding examples for various field types:\n\nScalar types:\n\n\"field_name\": uctypes.UINT32 | 0\n\nIn other words, value is scalar type identifier OR-ed with field offset (in bytes) from the start of the structure.\n\nRecursive structures:\n\n\"sub\": (2, {\n \"b0\": uctypes.UINT8 | 0,\n \"b1\": uctypes.UINT8 | 1,\n})\n\nI.e. value is a 2-tuple, first element of which is offset, and second is a structure descriptor dictionary (note: offsets in recursive descriptors are relative to a structure it defines).\n\nArrays of Primitive Types:\n\n\"arr\": (uctypes.ARRAY | 0, uctypes.UINT8 | 2),\n\nI.e. value is a 2-tuple, first element of which is ARRAY flag OR-ed with offset, and second is scalar element type OR-ed number of elements in array.\n\nArrays of Aggregate Types:\n\n\"arr2\": (uctypes.ARRAY | 0, 2, {\"b\": uctypes.UINT8 | 0}),\n\nI.e. value is a 3-tuple, first element of which is ARRAY flag OR-ed with offset, second is a number of elements in array, and third is descriptor of element type.\n\nPointer to a primitive type:\n\n\"ptr\": (uctypes.PTR | 0, uctypes.UINT8),\n\nI.e. value is a 2-tuple, first element of which is PTR flag OR-ed with offset, and second is scalar element type.\n\nPointer to an aggregate type:\n\n\"ptr2\": (uctypes.PTR | 0, {\"b\": uctypes.UINT8 | 0}),\n\nI.e. value is a 2-tuple, first element of which is PTR flag OR-ed with offset, second is descriptor of type pointed to.\n\nBitfields:\n\n\"bitf0\": uctypes.BFUINT16 | 0 | 0 \nI.e. value is type of scalar value containing given bitfield (typenames are similar to scalar types, but prefixes with \"BF\"), OR-ed with offset for scalar value containing the bitfield, and further OR-ed with values for bit offset and bit length of the bitfield within scalar value, shifted by BF_POS and BF_LEN positions, respectively. Bitfield position is counted from the least significant bit, and is the number of right-most bit of a field (in other words, it's a number of bits a scalar needs to be shifted right to extra the bitfield).\nIn the example above, first UINT16 value will be extracted at offset 0 (this detail may be important when accessing hardware registers, where particular access size and alignment are required), and then bitfield whose rightmost bit is least-significant bit of this UINT16, and length is 8 bits, will be extracted - effectively, this will access least-significant byte of UINT16.\nNote that bitfield operations are independent of target byte endianness, in particular, example above will access least-significant byte of UINT16 in both little- and big-endian structures. But it depends on the least significant bit being numbered 0. Some targets may use different numbering in their native ABI, but uctypes always uses normalised numbering described above.\nModule Contents\nclass uctypes.struct(addr, descriptor, layout_type=NATIVE)\nInstantiate a \"foreign data structure\" object based on structure address in memory, descriptor (encoded as a dictionary), and layout type (see below).\nuctypes.LITTLE_ENDIAN\nLayout type for a little-endian packed structure. (Packed means that every field occupies exactly as many bytes as defined in the descriptor, i.e. the alignment is 1).\nuctypes.BIG_ENDIAN\nLayout type for a big-endian packed structure.\nuctypes.NATIVE\nLayout type for a native structure - with data endianness and alignment conforming to the ABI of the system on which MicroPython runs.\nuctypes.sizeof(struct)\nReturn size of data structure in bytes. Argument can be either structure class or specific instantiated structure object (or its aggregate field).\nuctypes.addressof(obj)\nReturn address of an object. Argument should be bytes, bytearray or other object supporting buffer protocol (and address of this buffer is what actually returned).\nuctypes.bytes_at(addr, size)\nCapture memory at the given address and size as bytes object. As bytes object is immutable, memory is actually duplicated and copied into bytes object, so if memory contents change later, created object retains original value.\nuctypes.bytearray_at(addr, size)\nCapture memory at the given address and size as bytearray object. Unlike bytes_at() function above, memory is captured by reference, so it can be both written too, and you will access current value at the given memory address.\nStructure Descriptors and Instantiating Structure Objects\nGiven a structure descriptor dictionary and its layout type, you can instantiate a specific structure instance at a given memory address using uctypes.struct() constructor. Memory address usually comes from following sources:\n\nPredefined address, when accessing hardware registers on a baremetal system. Lookup these addresses in datasheet for a particular MCU/SoC.\nAs a return value from a call to some FFI (Foreign Function Interface) function.\nFrom uctypes.addressof(), when you want to pass arguments to an FFI function, or alternatively, to access some data for I/O (for example, data read from a file or network socket).\n\nStructure objects\nStructure objects allow accessing individual fields using standard dot notation: my_struct.substruct1.field1. If a field is of scalar type, getting it will produce a primitive value (Python integer or float) corresponding to the value contained in a field. A scalar field can also be assigned to.\nIf a field is an array, its individual elements can be accessed with the standard subscript operator [] - both read and assigned to.\nIf a field is a pointer, it can be dereferenced using [0] syntax (corresponding to C * operator, though [0] works in C too). Subscripting a pointer with other integer values but 0 are supported too, with the same semantics as in C.\nSumming up, accessing structure fields generally follows C syntax, except for pointer dereference, when you need to use [0] operator instead of *.\nLimitations\nAccessing non-scalar fields leads to allocation of intermediate objects to represent them. This means that special care should be taken to layout a structure which needs to be accessed when memory allocation is disabled (e.g. from an interrupt). The recommendations are:\n\nAvoid nested structures. For example, instead of mcu_registers.peripheral_a.register1, define separate layout descriptors for each peripheral, to be accessed as peripheral_a.register1.\nAvoid other non-scalar data, like array. For example, instead of peripheral_a.register[0] use peripheral_a.register0.\n\nNote that these recommendations will lead to decreased readability and conciseness of layouts, so they should be used only if the need to access structure fields without allocation is anticipated (it's even possible to define 2 parallel layouts - one for normal usage, and a restricted one to use when memory allocation is prohibited).\n"},"firmwareapi/micropython/sys.html":{"url":"firmwareapi/micropython/sys.html","title":"sys","keywords":"","body":"sys\nMethods\nsys.exit(retval=0)\nTerminate current program with a given exit code. Underlyingly, this function raise as SystemExit exception. If an argument is given, its value given as an argument to SystemExit.\nsys.print_exception(exc, file=sys.stdout)\nPrint exception with a traceback to a file-like object file (or sys.stdout by default).\nDifference to CPython\nThis is simplified version of a function which appears in the traceback module in CPython. Unlike traceback.print_exception(), this function takes just exception value instead of exception type, exception value, and traceback object; file argument should be positional; further arguments are not supported. CPython-compatible traceback module can be found in micropython-lib.\n\nConstants\n\nsys.argv: A mutable list of arguments the current program was started with.\nsys.byteorder: The byte order of the system (\"little\" or \"big\").\nsys.implementation: Object with information about the current Python implementation. For MicroPython, it has following attributes:\n\nname - string \"micropython\"\nversion - tuple (major, minor, micro), e.g. (1, 7, 0)\nThis object is the recommended way to distinguish MicroPython from other Python implementations (note that it still may not exist in the very minimal ports).\n\n\n\n\nDifference to CPython\nCPython mandates more attributes for this object, but the actual useful bare minimum is implemented in MicroPython.\n\n\nsys.maxsize: Maximum value which a native integer type can hold on the current platform, or maximum value representable by MicroPython integer type, if it's smaller than platform max value (that is the case for MicroPython ports without long int support).\n\nThis attribute is useful for detecting \"bitness\" of a platform (32-bit vs 64-bit, etc.). It's recommended to not compare this attribute to some value directly, but instead count number of bits in it:\nbits = 0\nv = sys.maxsize\nwhile v:\n bits += 1\n v >>= 1\nif bits > 32:\n # 64-bit (or more) platform\nelse:\n # 32-bit (or less) platform\n # Note that on 32-bit platform, value of bits may be less than 32\n # (e.g. 31) due to peculiarities described above, so use \"> 16\",\n # \"> 32\", \"> 64\" style of comparisons.\n\n\nsys.modules: Dictionary of loaded modules. On some ports, it may not include builtin modules.\nsys.path: A mutable list of directories to search for imported modules.\nsys.platform: The platform that MicroPython is running on. For OS/RTOS ports, this is usually an identifier of the OS, e.g. linux. For baremetal ports, it is an identifier of a board, e.g. pyboard for the original MicroPython reference board. It thus can be used to distinguish one board from another. If you need to check whether your program runs on MicroPython (vs other Python implementation), use sys.implementation instead.\nsys.stderr: Standard error stream.\nsys.stdin: Standard input stream.\nsys.stdout: Standard output stream.\nsys.version: Python language version that this implementation conforms to, as a string.\nsys.version_info: Python language version that this implementation conforms to, as a tuple of ints.\n\n"},"firmwareapi/micropython/uos.html":{"url":"firmwareapi/micropython/uos.html","title":"uos","keywords":"","body":"uos\nThe uos module contains functions for filesystem access and urandom function.\nPort Specifics\nThe filesystem has / as the root directory and the available physical drives are accessible from here. They are currently:\n\n/flash – the internal flash filesystem\n/sd – the SD card (if it exists)\n\nMethods\nuos.uname()\nReturn information about the system, firmware release version, and MicroPython interpreter version.\nuos.chdir(path)\nChange current directory.\nuos.getcwd()\nGet the current directory.\nuos.listdir([dir])\nWith no argument, list the current directory. Otherwise list the given directory.\nuos.mkdir(path)\nCreate a new directory.\nuos.remove(path)\nRemove a file.\nuos.rmdir(path)\nRemove a directory.\nuos.rename(old_path, new_path)\nRename a file.\nuos.stat(path)\nGet the status of a file or directory.\nThe return value is a tuple with the following 10 values, in order:\n\nst_mode: protection bits.\nst_ino: inode number. (not implemented, returns 0)\nst_dev: device. (not implemented, returns 0)\nst_nlink: number of hard links. (not implemented, returns 0)\nst_uid: user id of owner. (not implemented, returns 0)\nst_gid: group id of owner. (not implemented, returns 0)\nst_size: size of file in bytes.\nst_atime: time of most recent access.\nst_mtime: time of most recent content modification.\nst_ctime: time of most recent metadata change.\n\nuos.getfree(path)\nReturns the free space (in KiB) in the drive specified by path.\nuos.sync()\nSync all filesystems.\nuos.urandom(n)\nReturn a bytes object with n random bytes.\nuos.unlink(path)\nAlias for the remove() method.\nuos.mount(block_device, mount_point, * , readonly=False)\nMounts a block device (like an SD object) in the specified mount point. Example:\nos.mount(sd, '/sd')\nuos.unmount(path)\n\nUnmounts a previously mounted block device from the given path.\nuos.mkfs(block_device or path)\nFormats the specified path, must be either /flash or /sd. A block device can also be passed like an SD object before being mounted.\nuos.dupterm(stream_object)\nDuplicate the terminal (the REPL) on the passed stream-like object. The given object must at least implement the read() and write() methods.\nConstants\n\nuos.sep: Separation character used in paths\n\n"},"firmwareapi/micropython/array.html":{"url":"firmwareapi/micropython/array.html","title":"array","keywords":"","body":"array\nSee Python array for more information.\nSupported format codes: b, B, h, H, i, I, l, L, q, Q, f, d (the latter 2 depending on the floating-point support).\nClasses\nclass array.array(typecode[, iterable])\nCreate array with elements of given type. Initial contents of the array are given by an iterable. If it is not provided, an empty array is created.\nMethods\narray.append(val)\nAppend new element to the end of array, growing it.\narray.extend(iterable)\nAppend new elements as contained in an iterable to the end of array, growing it.\n"},"firmwareapi/micropython/cmath.html":{"url":"firmwareapi/micropython/cmath.html","title":"cmath","keywords":"","body":"cmath\nThe cmath module provides some basic mathematical functions for working with complex numbers. Floating point support required for this module.\nMethods\ncmath.cos(z)\nReturn the cosine of z.\ncmath.exp(z)\nReturn the exponential of z.\ncmath.log(z)\nReturn the natural logarithm of z. The branch cut is along the negative real axis.\ncmath.log10(z)\nReturn the base-10 logarithm of z. The branch cut is along the negative real axis.\ncmath.phase(z)\nReturns the phase of the number z, in the range (-pi, +pi).\ncmath.polar(z)\nReturns, as a tuple, the polar form of z.\ncmath.rect(r, phi)\nReturns the complex number with modulus r and phase phi.\ncmath.sin(z)\nReturn the sine of z.\ncmath.sqrt(z)\nReturn the square-root of z.\nConstants\n\ncmath.e: Base of the natural logarithm\ncmath.pi: The ratio of a circle's circumference to its diameter\n\n"},"firmwareapi/micropython/math.html":{"url":"firmwareapi/micropython/math.html","title":"math","keywords":"","body":"math\nThe math module provides some basic mathematical functions for working with floating-point numbers. Floating point support required for this module.\nMethods\nmath.acos(x)\nReturn the inverse cosine of x.\nmath.acosh(x)\nReturn the inverse hyperbolic cosine of x.\nmath.asin(x)\nReturn the inverse sine of x.\nmath.asinh(x)\nReturn the inverse hyperbolic sine of x.\nmath.atan(x)\nReturn the inverse tangent of x.\nmath.atan2(y, x)\nReturn the principal value of the inverse tangent of y/x.\nmath.atanh(x)\nReturn the inverse hyperbolic tangent of x.\nmath.ceil(x)\nReturn an integer, being x rounded towards positive infinity.\nmath.copysign(x, y)\nReturn x with the sign of y.\nmath.cos(x)\nReturn the cosine of x.\nmath.cosh(x)\nReturn the hyperbolic cosine of x.\nmath.degrees(x)\nReturn radians x converted to degrees.\nmath.erf(x)\nReturn the error function of x.\nmath.erfc(x)\nReturn the complementary error function of x.\nmath.exp(x)\nReturn the exponential of x.\nmath.expm1(x)\nReturn exp(x) - 1.\nmath.fabs(x)\nReturn the absolute value of x.\nmath.floor(x)\nReturn an integer, being x rounded towards negative infinity.\nmath.fmod(x, y)\nReturn the remainder of x/y.\nmath.frexp(x)\nDecomposes a floating-point number into its mantissa and exponent. The returned value is the tuple (m, e) such that x == m * 2**e exactly. If x == 0 then the function returns (0.0, 0), otherwise the relation 0.5 holds.\nmath.gamma(x)\nReturn the gamma function of x.\nmath.isfinite(x)\nReturn True if x is finite.\nmath.isinf(x)\nReturn True if x is infinite.\nmath.isnan(x)\nReturn True if x is not-a-number\nmath.ldexp(x, exp)\nReturn x * (2**exp).\nmath.lgamma(x)\nReturn the natural logarithm of the gamma function of x.\nmath.log(x)\nReturn the natural logarithm of x.\nmath.log10(x)\nReturn the base-10 logarithm of x.\nmath.log2(x)\nReturn the base-2 logarithm of x.\nmath.modf(x)\nReturn a tuple of two floats, being the fractional and integral parts of x. Both return values have the same sign as x.\nmath.pow(x, y)\nReturns x to the power of y.\nmath.radians(x)\nReturn degrees x converted to radians.\nmath.sin(x)\nReturn the sine of x.\nmath.sinh(x)\nReturn the hyperbolic sine of x.\nmath.sqrt(x)\nReturn the square root of x.\nmath.tan(x)\nReturn the tangent of x.\nmath.tanh(x)\nReturn the hyperbolic tangent of x.\nmath.trunc(x)\nReturn an integer, being x rounded towards 0.\nConstants\n\nmath.e: Base of the natural logarithm\nmath.pi: The ratio of a circle's circumference to its diameter\n\n"},"firmwareapi/micropython/gc.html":{"url":"firmwareapi/micropython/gc.html","title":"gc","keywords":"","body":"gc\nMethods\ngc.enable()\nEnable automatic garbage collection.\ngc.disable()\nDisable automatic garbage collection. Heap memory can still be allocated, and garbage collection can still be initiated manually using gc.collect().\ngc.collect()\nRun a garbage collection.\ngc.mem_alloc()\nReturn the number of bytes of heap RAM that are allocated.\ngc.mem_free()\nReturn the number of bytes of available heap RAM.\n"},"firmwareapi/micropython/ubinascii.html":{"url":"firmwareapi/micropython/ubinascii.html","title":"ubinascii","keywords":"","body":"ubinascii\nThis module implements conversions between binary data and various encodings of it in ASCII form (in both directions).\nMethods\nubinascii.hexlify(data[, sep])\nConvert binary data to hexadecimal representation. Returns bytes string.\nDifference to CPython\nIf additional argument, sep is supplied, it is used as a separator between hexadecimal values.\n\nubinascii.unhexlify(data)\nConvert hexadecimal data to binary representation. Returns bytes string. (i.e. inverse of hexlify)\nubinascii.a2b_base64(data)\nConvert Base64-encoded data to binary representation. Returns bytes string.\nubinascii.b2a_base64(data)\nEncode binary data in Base64 format. Returns string.\n"},"firmwareapi/micropython/ujson.html":{"url":"firmwareapi/micropython/ujson.html","title":"ujson","keywords":"","body":"ujson\nThis modules allows to convert between Python objects and the JSON data format.\nMethods\nujson.dumps(obj)\nReturn obj represented as a JSON string.\nujson.loads(str)\nParse the JSON str and return an object. Raises ValueError if the string is not correctly formed.\nujson.load(fp)\nParse contents of fp (a .read()-supporting file-like object containing a JSON document). Raises ValueError if the content is not correctly formed.\n"},"firmwareapi/micropython/ure.html":{"url":"firmwareapi/micropython/ure.html","title":"ure","keywords":"","body":"ure\nThis module implements regular expression operations. Regular expression syntax supported is a subset of CPython re module (and actually is a subset of POSIX extended regular expressions).\nSupported operators are:\n. Match any character. [] Match set of characters. Individual characters and ranges are supported.\n^\n$\n?\n*\n+\n??\n*?\n+?\n\nCounted repetitions ({m,n}), more advanced assertions, named groups, etc. are not supported.\nMethods\nure.compile(regex)\nCompile regular expression, return regex object.\nure.match(regex, string)\nMatch regex against string. Match always happens from starting position in a string.\nure.search(regex, string)\nSearch regex in a string. Unlike match, this will search string for first position which matches regex (which still may be 0 if regex is anchored).\nure.DEBUG\nFlag value, display debug information about compiled expression.\nRegex objects\nCompiled regular expression. Instances of this class are created using ure.compile().\nregex.match(string)\nregex.search(string)\nregex.split(string, max_split=-1)\nMatch objects\nMatch objects as returned by match() and search() methods.\nmatch.group([index])\nOnly numeric groups are supported.\n"},"firmwareapi/micropython/usocket.html":{"url":"firmwareapi/micropython/usocket.html","title":"usocket","keywords":"","body":"usocket\nThis module provides access to the BSD socket interface.\nSee corresponding CPython module for comparison.\nSocket Address Format(s)\nFunctions below which expect a network address, accept it in the format of (ipv4_address, port), where ipv4_address is a string with dot-notation numeric IPv4 address, e.g. 8.8.8.8, and port is integer port number in the range 1-65535. Note the domain names are not accepted as ipv4_address, they should be resolved first using socket.getaddrinfo().\nMethods\nsocket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)\nCreate a new socket using the given address family, socket type and protocol number.\nsocket.getaddrinfo(host, port)\nTranslate the host/port argument into a sequence of 5-tuples that contain all the necessary arguments for creating a socket connected to that service. The list of 5-tuples has following structure:\n(family, type, proto, canonname, sockaddr) The following example shows how to connect to a given url:\ns = socket.socket()\ns.connect(socket.getaddrinfo('www.micropython.org', 80)[0][-1])\n\nExceptions\nsocket.error, socket.timeout\nConstants\n\nFamily types: socket.AF_INET, socket.AF_LORA\nSocket types: socket.SOCK_STREAM, socket.SOCK_DGRAM, socket.SOCK_RAW\nSocket protocols: socket.IPPROTO_UDP, socket.IPPROTO_TCP\nSocket options layers: socket.SOL_SOCKET, socket.SOL_LORA, socket.SOL_SIGFOX\nIP socket options: socket.SO_REUSEADDR\nLoRa socket options: socket.SO_CONFIRMED, socket.SO_DR\nSigfox socket options: socket.SO_RX, socket.SO_TX_REPEAT, socket.SO_OOB, socket.SO_BIT\n\nclass Socket\nMethods\nsocket.close()\nMark the socket closed. Once that happens, all future operations on the socket object will fail. The remote end will receive no more data (after queued data is flushed).\nSockets are automatically closed when they are garbage-collected, but it is recommended to close() them explicitly, or to use a with statement around them.\nsocket.bind(address)\nBind the socket to address. The socket must not already be bound. The address parameter must be a tuple containing the IP address and the port.\nIn the case of LoRa sockets, the address parameter is simply an integer with the port number, for instance: s.bind(1)\n\nsocket.listen([backlog])\nEnable a server to accept connections. If backlog is specified, it must be at least 0 (if it's lower, it will be set to 0); and specifies the number of unaccepted connections that the system will allow before refusing new connections. If not specified, a default reasonable value is chosen.\nsocket.accept()\nAccept a connection. The socket must be bound to an address and listening for connections. The return value is a pair (conn, address) where conn is a new socket object usable to send and receive data on the connection, and address is the address bound to the socket on the other end of the connection.\nsocket.connect(address)\nConnect to a remote socket at address.\nsocket.send(bytes)\nSend data to the socket. The socket must be connected to a remote socket.\nsocket.sendall(bytes)\nAlias of socket.send(bytes).\nsocket.recv(bufsize)\nReceive data from the socket. The return value is a bytes object representing the data received. The maximum amount of data to be received at once is specified by bufsize.\nsocket.sendto(bytes, address)\nSend data to the socket. The socket should not be connected to a remote socket, since the destination socket is specified by address.\nsocket.recvfrom(bufsize)\nReceive data from the socket. The return value is a pair (bytes, address) where bytes is a bytes object representing the data received and address is the address of the socket sending the data.\nsocket.setsockopt(level, optname, value)\nSet the value of the given socket option. The needed symbolic constants are defined in the socket module (SO_* etc.). The value can be an integer or a bytes-like object representing a buffer.\nsocket.settimeout(value)\nSet a timeout on blocking socket operations. The value argument can be a nonnegative floating point number expressing seconds, or None. If a non-zero value is given, subsequent socket operations will raise a timeout exception if the timeout period value has elapsed before the operation has completed. If zero is given, the socket is put in non-blocking mode. If None is given, the socket is put in blocking mode.\nsocket.setblocking(flag)\nSet blocking or non-blocking mode of the socket: if flag is false, the socket is set to non-blocking, else to blocking mode.\nThis method is a shorthand for certain settimeout() calls:\nsock.setblocking(True) is equivalent to sock.settimeout(None)\nsock.setblocking(False) is equivalent to sock.settimeout(0.0)\n\nsocket.makefile(mode='rb')\nReturn a file object associated with the socket. The exact returned type depends on the arguments given to makefile(). The support is limited to binary modes only (rb and wb). CPython's arguments: encoding, errors, and newline are not supported.\nThe socket must be in blocking mode; it can have a timeout, but the file object's internal buffer may end up in a inconsistent state if a timeout occurs.\nDifference to CPython\nClosing the file object returned by makefile() WILL close the original socket as well.\n\nsocket.read(size)\nRead up to size bytes from the socket. Return a bytes object. If size is not given, it behaves just like socket.readall(), see below.\nsocket.readall()\nRead all data available from the socket until EOF. This function will not return until the socket is closed.\nsocket.readinto(buf[, nbytes])\nRead bytes into the buf. If nbytes is specified then read at most that many bytes. Otherwise, read at most len(buf) bytes.\nReturn value: number of bytes read and stored into buf.\nsocket.readline()\nRead a line, ending in a newline character.\nReturn value: the line read.\nsocket.write(buf)\nWrite the buffer of bytes to the socket.\nReturn value: number of bytes written.\n"},"firmwareapi/micropython/select.html":{"url":"firmwareapi/micropython/select.html","title":"select","keywords":"","body":"select\nThis module provides functions to wait for events on streams (select streams which are ready for operations).\nPyboard specifics\nPolling is an efficient way of waiting for read/write activity on multiple objects. Current objects that support polling are: pyb.UART, pyb.USB_VCP.\nMethods\nselect.poll()\nCreate an instance of the Poll class.\nselect.select(rlist, wlist, xlist[, timeout])\nWait for activity on a set of objects.\nThis function is provided for compatibility and is not efficient. Usage of Poll is recommended instead.\nclass Poll\nMethods\npoll.register(obj[, eventmask])\nRegister obj for polling. eventmask is logical OR of:\n\nselect.POLLIN - data available for reading\nselect.POLLOUT - more data can be written\nselect.POLLERR - error occurred\nselect.POLLHUP - end of stream/connection termination detected\neventmask defaults to select.POLLIN | select.POLLOUT.\n\n\npoll.unregister(obj)\nUnregister obj from polling.\npoll.modify(obj, eventmask)\nModify the eventmask for obj.\npoll.poll([timeout])\nWait for at least one of the registered objects to become ready. Returns list of (obj, event, ...) tuples, event element specifies which events happened with a stream and is a combination of select.POLL* constants described above. There may be other elements in tuple, depending on a platform and version, so don't assume that its size is 2. In case of timeout, an empty list is returned.\nTimeout is in milliseconds.\n"},"firmwareapi/micropython/utime.html":{"url":"firmwareapi/micropython/utime.html","title":"utime","keywords":"","body":"utime\nThe utime module provides functions for getting the current time and date, measuring time intervals, and for delays.\nTime Epoch: Pycom's ESP32 port uses standard for POSIX systems epoch of 1970-01-01 00:00:00 UTC.\nMaintaining actual calendar date/time\nThis requires a Real Time Clock (RTC). On systems with underlying OS (including some RTOS), an RTC may be implicit. Setting and maintaining actual calendar time is responsibility of OS/RTOS and is done outside of MicroPython, it just uses OS API to query date/time. On baremetal ports however system time depends on machine.RTC() object. The current calendar time may be set using machine.RTC().datetime(tuple) function, and maintained by following means:\n\nBy a backup battery (which may be an additional, optional component for a particular board).\nUsing networked time protocol (requires setup by a port/user).\nSet manually by a user on each power-up (many boards then maintain RTC time across hard resets, though some may require setting it again in such case).\n\nIf actual calendar time is not maintained with a system/MicroPython RTC, functions below which require reference to current absolute time may behave not as expected.\nMethods\nutime.gmtime([secs])\nConvert a time expressed in seconds since the Epoch (see above) into an 8-tuple which contains: (year, month, mday, hour, minute, second, weekday, yearday) If secs is not provided or None, then the current time from the RTC is used.\n\nyear includes the century (for example 2014).\nmonth is 1-12\nmday is 1-31\nhour is 0-23\nminute is 0-59\nsecond is 0-59\nweekday is 0-6 for Mon-Sun\nyearday is 1-366\n\nutime.localtime([secs])\nLike gmtime() but converts to local time. If secs is not provided or None, the current time from the RTC is used.\nutime.mktime()\nThis is inverse function of localtime. It's argument is a full 8-tuple which expresses a time as per localtime. It returns an integer which is the number of seconds since Jan 1, 2000.\nutime.sleep(seconds)\nSleep for the given number of seconds. seconds can be a floating-point number to sleep for a fractional number of seconds. Note that other MicroPython ports may not accept floating-point argument, for compatibility with them use sleep_ms() and sleep_us() functions.\nutime.sleep_ms(ms)\nDelay for given number of milliseconds, should be positive or 0.\nutime.sleep_us(us)\nDelay for given number of microseconds, should be positive or 0\nutime.ticks_ms()\nReturns uptime, in milliseconds.\nutime.ticks_us()\nJust like ticks_ms above, but in microseconds.\nutime.ticks_cpu()\nSame as ticks_us, but faster.\nutime.ticks_diff(old, new)\nMeasure period between consecutive calls to ticks_ms(), ticks_us(), or ticks_cpu(). The value returned by these functions may wrap around at any time, so directly subtracting them is not supported. ticks_diff() should be used instead. \"old\" value should actually precede \"new\" value in time, or result is undefined. This function should not be used to measure arbitrarily long periods of time (because ticks_*() functions wrap around and usually would have short period). The expected usage pattern is implementing event polling with timeout:\n# Wait for GPIO pin to be asserted, but at most 500us\nstart = time.ticks_us()\nwhile pin.value() == 0:\n if time.ticks_diff(start, time.ticks_us()) > 500:\n raise TimeoutError\n\nutime.time()\nReturns the number of seconds, as an integer, since the Epoch, assuming that underlying RTC is set. If an RTC is not set, this function returns number of seconds since power up or reset). If you want to develop portable MicroPython application, you should not rely on this function to provide higher than second precision. If you need higher precision, use ticks_ms() and ticks_us() functions, if you need calendar time, localtime() without an argument is a better choice.\nutime.timezone([secs])\nSet or get the timezone offset, in seconds. If secs is not provided, it returns the current value.\nIn MicroPython, time.timezone works the opposite way to Python. In Python, to get the local time, you write local_time = utc - timezone, while in MicroPython it is local_time = utc + timezone.\n\n"},"firmwareapi/micropython/uhashlib.html":{"url":"firmwareapi/micropython/uhashlib.html","title":"uhashlib","keywords":"","body":"uhashlib\nThis module implements binary data hashing algorithms. MD5 and SHA are supported. By limitations in the hardware, only one active hashing operation is supported at a time.\nConstructors\nclass uhashlib.md5([data])\nCreate a MD5 hasher object and optionally feed data into it.\nclass uhashlib.sha1([data])\nCreate a SHA-1 hasher object and optionally feed data into it.\nclass uhashlib.sha224([data])\nCreate a SHA-224 hasher object and optionally feed data into it.\nclass uhashlib.sha256([data])\nCreate a SHA-256 hasher object and optionally feed data into it.\nclass uhashlib.sha384([data])\nCreate a SHA-384 hasher object and optionally feed data into it.\nclass uhashlib.sha512([data])\nCreate a SHA-512 hasher object and optionally feed data into it.\nMethods\nhash.update(data)\nFeed more binary data into hash.\nhash.digest()\nReturn hash for all data passed through hash, as a bytes object. After this method is called, more data cannot be fed into hash any longer.\nhash.hexdigest()\nThis method is NOT implemented. Use ubinascii.hexlify(hash.digest()) to achieve a similar effect.\n"},"firmwareapi/micropython/ussl.html":{"url":"firmwareapi/micropython/ussl.html","title":"ussl","keywords":"","body":"ussl\nThis module provides access to Transport Layer Security (often known as \"Secure Sockets Layer\") encryption and peer authentication facilities for network sockets, both client-side and server-side.\nMethods\nssl.wrap_socket(sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ca_certs=None)\nTakes an instance sock of socket.socket, and returns an instance of ssl.SSLSocket, a subtype of socket.socket, which wraps the underlying socket in an SSL context. Example:\nimport socket\nimport ssl\ns = socket.socket()\nss = ssl.wrap_socket(s)\nss.connect(socket.getaddrinfo('www.google.com', 443)[0][-1])\n\nCertificates must be used in order to validate the other side of the connection, and also to authenticate ourselves with the other end. Such certificates must be stored as files using the FTP server, and they must be placed in specific paths with specific names.\nFor instance, to connect to the Blynk servers using certificates, take the file ca.pem located in the blynk examples folder and put it in /flash/cert/. Then do:\nimport socket\nimport ssl\ns = socket.socket()\nss = ssl.wrap_socket(s, cert_reqs=ssl.CERT_REQUIRED, ca_certs='/flash/cert/ca.pem')\nss.connect(socket.getaddrinfo('cloud.blynk.cc', 8441)[0][-1])\n\nSSL sockets inherit all methods and from the standard sockets, see the usocket module.\nExceptions\n\nssl.SSLError\n\nConstants\n\nssl.CERT_NONE, ssl.CERT_OPTIONAL, ssl.CERT_REQUIRED: Supported values in cert_reqs\n\n"},"firmwareapi/micropython/ucrypto.html":{"url":"firmwareapi/micropython/ucrypto.html","title":"ucrypto","keywords":"","body":"ucrypto\nThis module provides native support for cryptographic algorithms. It's loosely based on PyCrypto.\nClasses\n\nclass AES - Advanced Encryption Standard\n\nMethods\ncrypto.getrandbits(bits)\nReturns a bytes object filled with random bits obtained from the hardware random number generator.\nAccording to the ESP32 Technical Reference Manual, such bits \"... can be used as the basis for cryptographical operations\". \"These true random numbers are generated based on the noise in the Wi-Fi/BT RF system. When Wi-Fi and BT are disabled, the random number generator will give out pseudo-random numbers.\"\nThe parameter bits is rounded upwards to the nearest multiple of 32 bits.\nCryptography is not a trivial business. Doing things the wrong way could quickly result in decreased or no security. Please document yourself in the subject if you are depending on encryption to secure important information.\n\n"},"firmwareapi/micropython/ustruct.html":{"url":"firmwareapi/micropython/ustruct.html","title":"ustruct","keywords":"","body":"ustruct\nSee Python struct for more information.\nSupported size/byte order prefixes: @, , !.\nSupported format codes: b, B, h, H, i, I, l, L, q, Q, s, P, f, d (the latter 2 depending on the floating-point support).\nMethods\nustruct.calcsize(fmt)\nReturn the number of bytes needed to store the given fmt.\nustruct.pack(fmt, v1, v2, ...)\nPack the values v1, v2, ... according to the format string fmt. The return value is a bytes object encoding the values.\nustruct.pack_into(fmt, buffer, offset, v1, v2, ...)\nPack the values v1, v2, ... according to the format string fmt into a buffer starting at offset. offset may be negative to count from the end of buffer.\nustruct.unpack(fmt, data)\nUnpack from the data according to the format string fmt. The return value is a tuple of the unpacked values.\nustruct.unpack_from(fmt, data, offset=0)\nUnpack from the data starting at offset according to the format string fmt. offset may be negative to count from the end of buffer. The return value is a tuple of the unpacked values.\n"},"firmwareapi/micropython/_thread.html":{"url":"firmwareapi/micropython/_thread.html","title":"_thread","keywords":"","body":"_thread\nThis module provides low-level primitives for working with multiple threads (also called light-weight processes or tasks) — multiple threads of control sharing their global data space. For synchronisation, simple locks (also called mutexes or binary semaphores) are provided.\nWhen a thread specific error occurs a RuntimeError exception is raised.\nQuick Usage Example\nimport _thread\nimport time\n\ndef th_func(delay, id):\n while True:\n time.sleep(delay)\n print('Running thread %d' % id)\n\nfor i in range(2):\n _thread.start_new_thread(th_func, (i + 1, i))\n\nMethods\n_thread.start_new_thread(function, args[, kwargs])\nStart a new thread and return its identifier. The thread executes the function with the argument list args (which must be a tuple). The optional kwargs argument specifies a dictionary of keyword arguments. When the function returns, the thread silently exits. When the function terminates with an unhandled exception, a stack trace is printed and then the thread exits (but other threads continue to run).\n_thread.exit()\nRaise the SystemExit exception. When not caught, this will cause the thread to exit silently.\n_thread.allocate_lock()\nReturn a new lock object. Methods of locks are described below. The lock is initially unlocked.\n_thread.get_ident()\nReturn the thread identifier of the current thread. This is a nonzero integer. Its value has no direct meaning; it is intended as a magic cookie to be used e.g. to index a dictionary of thread-specific data. Thread identifiers may be recycled when a thread exits and another thread is created.\n_thread.stack_size([size])\nReturn the thread stack size (in bytes) used when creating new threads. The optional size argument specifies the stack size to be used for subsequently created threads, and must be 0 (use platform or configured default) or a positive integer value of at least 4096 (4KiB). 4KiB is currently the minimum supported stack size value to guarantee sufficient stack space for the interpreter itself.\nObjects\n_thread.LockType\nThis is the type of lock objects.\nclass Lock\nUsed for synchronisation between threads\nMethods\nLock objects have the following methods:\nlock.acquire(waitflag=1, timeout=-1)\nWithout any optional argument, this method acquires the lock unconditionally, if necessary waiting until it is released by another thread (only one thread at a time can acquire a lock — that's their reason for existence).\nIf the integer waitflag argument is present, the action depends on its value: if it is zero, the lock is only acquired if it can be acquired immediately without waiting, while if it is nonzero, the lock is acquired unconditionally as above.\nIf the floating-point timeout argument is present and positive, it specifies the maximum wait time in seconds before returning. A negative timeout argument specifies an unbounded wait. You cannot specify a timeout if waitflag is zero.\nThe return value is True if the lock is acquired successfully, False if not.\nlock.release()\nReleases the lock. The lock must have been acquired earlier, but not necessarily by the same thread.\nlock.locked()\nReturn the status of the lock: True if it has been acquired by some thread, False if not.\nIn addition to these methods, lock objects can also be used via the with statement, e.g.:\nimport _thread\n\na_lock = _thread.allocate_lock()\n\nwith a_lock:\n print(\"a_lock is locked while this executes\")\n\n"},"firmwareapi/micropython/builtin.html":{"url":"firmwareapi/micropython/builtin.html","title":"Builtin","keywords":"","body":"Builtin\nAll builtin functions are described here. They are also available via builtins module.\nabs()\nall()\nany()\nbin()\nclass bool\nclass bytearray\nclass bytes\ncallable()\nchr()\nclass method()\ncompile()\nclass complex\nclass dict\ndir()\ndivmod()\nenumerate()\neval()\nexec()\nfilter()\nclass float\nclass frozenset\ngetattr()\nglobals()\nhasattr()\nhash()\nhex()\nid()\ninput()\nclass int\nisinstance()\nissubclass()\niter()\nlen()\nclass list\nlocals()\nmap()\nmax()\nclass memoryview\nmin()\nnext()\nclass object\noct()\nopen()\nord()\npow()\nprint()\nproperty()\nrange()\nrepr()\nreversed()\nround()\nclass set\nsetattr()\nsorted()\nstaticmethod()\nclass str\nsum()\nsuper()\nclass tuple\ntype()\nzip()\n"},"firmwareapi/notes.html":{"url":"firmwareapi/notes.html","title":"Notes","keywords":"","body":"Notes\nInterrupt Handling\nIn Pycom's ESP32 MicroPython port there are no restrictions on what can be done within an interrupt handler. For example, other ports do not allow allocating memory inside the handler or the use of sockets.\nThese limitations were raised by handling the interrupt events differently. When an interrupt happens, a message is posted into a queue, notifying a separate thread that the appropriate callback handler should be called. Such handler would receive an argument. By default it is the object associated with the event.\nThe user can do whatever is required inside of the callback, such as creating new variables, or even sending network packets. Bear in mind that interrupts are processed sequentially and thus it is ideal to keep the handlers as short as possible in order to attend all of them in the minimum time.\nCurrently, there are 2 classes that support interrupts; the Alarm and Pin classes. Both classes provide the .callback() method that enables the interrupt and registers the given handler. For more details about interrupt usage along with examples, please visit their respective sections.\nCurrently the interrupt system can queue up to 16 interrupts.\n\n"},"datasheets/introduction.html":{"url":"datasheets/introduction.html","title":"Introduction","keywords":"","body":"Introduction\nThe follow pages contain all information relating to each product, for examples: pinouts, spec sheets, relevant examples and notes.\nDevelopment Modules\nOEM modules\nExpansion Boards and Shields\n"},"datasheets/development/":{"url":"datasheets/development/","title":"Development Modules","keywords":"","body":"Development Modules\nThis section contains all of the datasheets for the Pycom Development Devices. This includes the WiPy 2.0 and 3.0, LoPy, LoPy 4, SiPy, GPy, and FiPy.\n"},"datasheets/development/wipy2.html":{"url":"datasheets/development/wipy2.html","title":"WiPy 2.0","keywords":"","body":"WiPy 2.0\n**** **\nStore: Discontinued, See WiPy3\nGetting Started: Click Here\nDatasheet\nThe datasheet of the WiPy2 is available as a PDF File.\nWiPy 2 Datasheet\nPinout\nThe pinout of the WiPy2 is available as a PDF File.\nWiPy 2 Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the WiPy2 will create a WiFi access point with the SSID wipy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nPower\nThe Vin pin on the WiPy2 can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the WiPy2, otherwise the on-board regulator will be damaged.\nDeep Sleep\nDue to a couple issues with the WiPy2 design the module draws more current than it should while in deep sleep. The DC-DC switching regulator always stays in high performance mode which is used to provide the lowest possible output ripple when the modules is in use. In this mode, it draws a quiescent current of 10mA. When the regulator is put into ECO mode, the quiescent current goes down to 10uA. Unfortunately, the pin used to control this mode is out of the RTC domain, and therefore not usable during deep sleep. This causes the regulator to always stay in PWM mode, keeping its quiescent current at 10mA. Alongside this the flash chip doesn't enter power down mode because the CS pin is floating during deep sleep. This causes the flash chip to consume around 2mA of current. To work around this issue a \"deep sleep shield\" is available that attaches to the module and allows power to be cut off from the device. The device can then be re-enabled either on a timer or via pin interrupt. With the deep sleep shield the current consumption during deep sleep is between 7uA and 10uA depending on the wake sources configured.\nTutorials\nTutorials on how to the WiPy2 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the WiPy2:\n\nWiFi connection\nBLE\n\n"},"datasheets/development/wipy3.html":{"url":"datasheets/development/wipy3.html","title":"WiPy 3.0","keywords":"","body":"WiPy 3.0\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the WiPy3 is available as a PDF File.\nWiPy3 Datasheet\nPinout\nThe pinout of the WiPy3 is available as a PDF File.\nWiPy3 Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nDifferences from WiPy 2.0\n\nDeep sleep current draw fixed, now only 19.7µA\nUpgraded RAM from 512KB to 4MB\nUpgraded External FLASH from 4MB to 8MB\nAntenna select pin moved from GPIO16 to GPIO21 (P12)\n\nNotes\nWiFi\nBy default, upon boot the WiPy3 will create a WiFi access point with the SSID wipy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nThe RF switch that selects between the on-board and external antenna is connected to P12, for this reason using P12 should be avoided unless WiFi is disabled in your application.\nPower\nThe Vin pin on the WiPy3 can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the WiPy3, otherwise the on-board regulator will be damaged.\nTutorials\nTutorials on how to the WiPy3 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the WiPy3:\n\nWiFi connection\nBLE\n\n"},"datasheets/development/lopy.html":{"url":"datasheets/development/lopy.html","title":"LoPy","keywords":"","body":"LoPy\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the LoPy is available as a PDF File.\nLoPy Datasheet\nPinout\nThe pinout of the LoPy is available as a PDF File\nLoPy Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the LoPy will create a WiFi access point with the SSID lopy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nPower\nThe Vin pin on the LoPy can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the LoPy, otherwise the on-board regulator will be damaged.\nDeep Sleep\nDue to a couple issues with the LoPy design the module draws more current than it should while in deep sleep. The DC-DC switching regulator always stays in high performance mode which is used to provide the lowest possible output ripple when the modules is in use. In this mode, it draws a quiescent current of 10mA. When the regulator is put into ECO mode, the quiescent current goes down to 10uA. Unfortunately, the pin used to control this mode is out of the RTC domain, and therefore not usable during deep sleep. This causes the regulator to always stay in PWM mode, keeping its quiescent current at 10mA. Alongside this the flash chip doesn't enter power down mode because the CS pin is floating during deep sleep. This causes the flash chip to consume around 2mA of current. To work around this issue a \"deep sleep shield\" is available that attaches to the module and allows power to be cut off from the device. The device can then be re-enabled either on a timer or via pin interrupt. With the deep sleep shield the current consumption during deep sleep is between 7uA and 10uA depending on the wake sources configured.\nTutorials\nTutorials on how to the LoPy module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the LoPy:\n\nWiFi connection\nLoRaWAN node\nLoRaWAN nano gateway\nBLE\n\n"},"datasheets/development/lopy4.html":{"url":"datasheets/development/lopy4.html","title":"LoPy 4","keywords":"","body":"LoPy 4\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the LoPy4 is available as a PDF File.\nLoPy4 Datasheet\nPinout\nThe pinout of the LoPy4 is available as a PDF File\nLoPy4 Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the LoPy4 will create a WiFi access point with the SSID lopy4-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nThe RF switch that selects between the on-board and external antenna is connected to P12, for this reason using P12 should be avoided unless WiFi is disabled in your application.\nPower\nThe Vin pin on the LoPy4 can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the LoPy4, otherwise the on-board regulator will be damaged.\nTutorials\nTutorials on how to the LoPy4 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the LoPy4:\n\nWiFi connection\nLoRaWAN node\nLoRaWAN nano gateway\nSigfox\nBLE\n\n"},"datasheets/development/sipy.html":{"url":"datasheets/development/sipy.html","title":"SiPy","keywords":"","body":"SiPy\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the SiPy is available as a PDF File.\nSiPy Datasheet\nPinout\nThe pinout of the SiPy is available as a PDF File\nSiPy Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the SiPy will create a WiFi access point with the SSID sipy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nPower\nThe Vin pin on the SiPy can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the SiPy, otherwise the on-board regulator will be damaged.\nDeep Sleep\nDue to a couple issues with the SiPy design the module draws more current than it should while in deep sleep. The DC-DC switching regulator always stays in high performance mode which is used to provide the lowest possible output ripple when the modules is in use. In this mode, it draws a quiescent current of 10mA. When the regulator is put into ECO mode, the quiescent current goes down to 10uA. Unfortunately, the pin used to control this mode is out of the RTC domain, and therefore not usable during deep sleep. This causes the regulator to always stay in PWM mode, keeping its quiescent current at 10mA. Alongside this the flash chip doesn't enter power down mode because the CS pin is floating during deep sleep. This causes the flash chip to consume around 2mA of current. To work around this issue a \"deep sleep shield\" is available that attaches to the module and allows power to be cut off from the device. The device can then be re-enabled either on a timer or via pin interrupt. With the deep sleep shield the current consumption during deep sleep is between 7uA and 10uA depending on the wake sources configured.\nTutorials\nTutorials on how to the SiPy module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the SiPy:\n\nWiFi connection\nSigfox\nBLE\n\n"},"datasheets/development/gpy.html":{"url":"datasheets/development/gpy.html","title":"GPy","keywords":"","body":"GPy\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the GPy is available as a PDF File.\nGPy Datasheet\nThe drawing of the LTE-M antenna is available as a PDF File.\nLTE-M Antenna Drawing\nPinout\nThe pinout of the GPy is available as a PDF File\nGPy Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the GPy will create a WiFi access point with the SSID gpy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nThe RF switch that selects between the on-board and external antenna is connected to P12, for this reason using P12 should be avoided unless WiFi is disabled in your application.\nPower\nThe Vin pin on the GPy can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the GPy, otherwise the on-board regulator will be damaged.\nAT Commands\nThe AT commands for the Sequans Monarch modem on the GPy are available in a PDF file.\nAT Commands for Sequans\nTutorials\nTutorials on how to the GPy module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the GPy:\n\nWiFi connection\nLTE CAT-M1\nNB-IoT\nBLE\n\n"},"datasheets/development/fipy.html":{"url":"datasheets/development/fipy.html","title":"FiPy","keywords":"","body":"FiPy\n**** **\nStore: Buy Here\nGetting Started: Click Here\nDatasheet\nThe datasheet of the FiPy is available as a PDF File.\nFiPy Datasheet\nThe drawing of the LTE-M antenna is available as a PDF File.\nLTE-M Antenna Drawing\nPinout\nThe pinout of the FiPy is available as a PDF File\nFiPy Pinout\n\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nNotes\nWiFi\nBy default, upon boot the FiPy will create a WiFi access point with the SSID fipy-wlan-XXXX, where XXXX is a random 4-digit number, and the password www.pycom.io.\nThe RF switch that selects between the on-board and external antenna is connected to P12, for this reason using P12 should be avoided unless WiFi is disabled in your application.\nPower\nThe Vin pin on the FiPy can be supplied with a voltage ranging from 3.5v to 5.5v. The 3.3v pin on the other hand is output only, and must not be used to feed power into the FiPy, otherwise the on-board regulator will be damaged.\nAT Commands\nThe AT commands for the Sequans Monarch modem on the FiPy are available in a PDF file.\nAT Commands for Sequans\nTutorials\nTutorials on how to the FiPy module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the FiPy:\n\nWiFi connection\nLoRaWAN node\nLoRaWAN nano gateway\nSigfox\nLTE CAT-M1\nNB-IoT\nBLE\n\n"},"datasheets/oem/":{"url":"datasheets/oem/","title":"OEM Modules","keywords":"","body":"OEM Modules\nThis section contains all of the datasheets for the Pycom OEM Devices. This includes the W01, L01, L04, and G01.\n"},"datasheets/oem/w01.html":{"url":"datasheets/oem/w01.html","title":"W01","keywords":"","body":"W01\n\nDatasheet\nThe datasheet of the W01 is available as a PDF File.\nW01 Datasheet\nPinout\nThe pinout of the W01 is available as a PDF File\nW01 Pinout\n\nDrawings\nThe drawings for the W01 is available as a PDF File.\nW01 Drawings\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nTutorials\nTutorials on how to the W01 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the W01:\n\nWiFi connection\nBLE\n\n"},"datasheets/oem/l01.html":{"url":"datasheets/oem/l01.html","title":"L01","keywords":"","body":"L01\n \nDatasheet\nThe datasheet of the L01 is available as a PDF File.\nL01 Datasheet\nPinout\nThe pinout of the L01 is available as a PDF File\nL01 Pinout\n\nDrawings\nThe drawings for the L01 is available as a PDF File.\nL01 Drawing\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nTutorials\nTutorials on how to the L01 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the L01:\n\nWiFi connection\nLoRaWAN node\nLoRaWAN nano gateway\nBLE\n\n"},"datasheets/oem/l04.html":{"url":"datasheets/oem/l04.html","title":"L04","keywords":"","body":"L04\n \nDatasheet\nThe datasheet of the L04 is available as a PDF File.\nL04 Datasheet\nPinout\nThe pinout of the L04 is available as a PDF File\nL04 Pinout\n\nDrawings\nThe drawings for the L04 is available as a PDF File.\nL04 Drawings\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nTutorials\nTutorials on how to the L04 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the L04:\n\nWiFi connection\nLoRaWAN node\nLoRaWAN nano gateway\nSigfox\nBLE\n\n"},"datasheets/oem/g01.html":{"url":"datasheets/oem/g01.html","title":"G01","keywords":"","body":"G01\n\nDatasheet\nThe datasheet of the G01 is available as a PDF File.\nG01 Datasheet\nPinout\nThe pinout of the G01 is available as a PDF File\nG01 Pinout\n\nDrawings\nThe drawings for the G01 is available as a PDF File.\nG01 Drawings\nPlease note that the PIN assignments for UART1 (TX1/RX1), SPI (CLK, MOSI, MISO) and I2C (SDA, SCL) are defaults and can be changed in Software.\n\nAT Commands\nThe AT commands for the Sequans Monarch modem on the G01 are available in a PDF file.\nAT Commands for Sequans\nTutorials\nTutorials on how to the G01 module can be found in the examples section of this documentation. The following tutorials might be of specific interest for the G01:\n\nWiFi connection\nLTE CAT-M1\nNB-IoT\nBLE\n\n"},"datasheets/oem/l01_reference.html":{"url":"datasheets/oem/l01_reference.html","title":"L01 OEM Baseboard Reference","keywords":"","body":"L01 OEM Baseboard Reference\n\nThe L01 OEM reference board is a reference design suitable L01 as well as W01 making it possible to have a single PCB design that can accommodate both OEM modules.\nIf you require a reference board for the L04 or G01, this design is not suitable as it does not feature a SIM slot or the double antenna connection. For the G01 or L04 please use the Universal OEM Baseboard Reference\n\nFeatures\n\nSuits both L01 or W01 OEM Modules\nU.FL connector for the L01's LoRa output.\nOn-board 2.4GHz antenna for WiFi and Bluetooth, with the ability to switch\nto a external antenna via a U.FL connector.\n\nWS2812B RGB LED\n\n3.5-5.5 Input switch mode DC-DC regulator with low current draw during deep\nsleep\n\nReset button\n\n\nLayout\nThe layout of the L01 baseboard reference is available as a PDF File\nL01 OEM Layout/gitbook/assets/l01-oem-layout.pdf)\n\nSchematic\nThe schematic of the L01 baseboard reference is available as a PDF File.\nL01 OEM Schematic\nAltium Project and Gerber Files\nThe Altium Project and Gerber files are also available as a ZIP File.\nL01 OEM Altium Project and Gerber Files\n"},"datasheets/oem/universal_reference.html":{"url":"datasheets/oem/universal_reference.html","title":"Universal OEM Baseboard Reference","keywords":"","body":"Universal OEM Baseboard Reference\n\nThe universal OEM reference board is a reference design suitable W01, L01, L04 and G01 OEM modules, making it possible to have a single PCB design that can accommodate all our OEM modules.\nIf you require a reference board for the G01, only this design is suitable. The L01 reference board does not contain the necessary SIM slot.\n\nFeatures\n\nSuits all OEM modules (L01, L04, W01, G01)\nOn-board 2.4GHz antenna for WiFi and Bluetooth, with the ability to switch\nto a external antenna via a U.FL connector.\n\n3 U.FL connectors for all the outputs available on the OEM modules\n\nWS2812B RGB LED\n3.5-5.5 Input switch mode DC-DC regulator with low current draw during deep\nsleep\n\nReset button\n\n\nLayout\nThe layout of the OEM baseboard reference is available as a PDF File\nOEM Layout\n\nSchematic\nThe schematic of the OEM baseboard reference is available as a PDF File.\nOEM Schematic\nAltium Project and Gerber Files\nThe Altium Project and Gerber files are also available as a ZIP File.\nOEM Altium Project and Gerber Files\n"},"datasheets/boards/":{"url":"datasheets/boards/","title":"Expansion Boards and Shields","keywords":"","body":"Expansion Boards and Shields\nThis section contains all of the datasheets for the Pycom Expansion Boards and Shields. This includes the Expansion Board, Pytrack, Pysense and Deep Sleep Shield.\n"},"datasheets/boards/expansion3.html":{"url":"datasheets/boards/expansion3.html","title":"Expansion Board 3.0","keywords":"","body":"Expansion Board 3.0\n\nDatasheet\nThe datasheet of the Expansion Board is available as a PDF File.\nOEM Altium Project and Gerber Files\nPinout\nThe pinout of the Expansion Board is available as a PDF File\nExpansion Board 3 Pinout\n\nBe gentle when plugging/unplugging from the USB connector. Whilst the USB connector is soldered and is relatively strong, if it breaks off it can be very difficult to fix.\n\nBattery Charger\nThe Expansion Board features a single cell Li-Ion/Li-Po charger. When the board is being powered via the micro USB connector, the Expansion Board will charge the battery (if connected). When the CHG jumper is present the battery will be charged at 450mA. If this value is too high for your application, removing the jumper lowers the charge current to 100mA.\nTo use the battery, pull P8/G15 high (connect to 3v3). If you want to use the SD card as well, use a 10k pull-up.\n\nDifferences between v2.0 and v3.0\n\nThe FTDI chip as been replaced with a custom programmed PIC like on the\nPysense/Pytrack/Pyscan boards. This allows our firmware update tool to\nautomatically put the module into bootloader mode.\n\nAdded a \"Safe boot\" button to enter safe boot easier. This button connects\nP12 to 3.3v and if pressed and held while the reset button is pressed on\na Pycom module, the module will enter safe boot.\n\n\nTroubleshooting\n\nIf PIC stays in bootloader mode, the dfu-util update should be performed\n\n"},"datasheets/boards/pytrack.html":{"url":"datasheets/boards/pytrack.html","title":"Pytrack","keywords":"","body":"Pytrack\n \nDatasheet\nThe datasheet of the Pytrack is available as a PDF File.\nPytrack Datasheet\nPinout\nThe pinout of the Pytrack is available as a PDF File\nPytrack Pinout\n\nBattery Charger\nThe board features a single cell Li-Ion/Li-Po charger. When the board is being powered via the micro USB connector, it will charge the battery (if connected).\n"},"datasheets/boards/pysense.html":{"url":"datasheets/boards/pysense.html","title":"Pysense","keywords":"","body":"Pysense\n \nDatasheet\nThe datasheet of the Pysense is available as a PDF File.\nPysense Datasheet\nPinout\nThe pinout of the Pysense is available as a PDF File\nPysense Pinout\n\nBattery Charger\nThe board features a single cell Li-Ion/Li-Po charger. When the board is being powered via the micro USB connector, it will charge the battery (if connected).\n"},"datasheets/boards/pyscan.html":{"url":"datasheets/boards/pyscan.html","title":"Pyscan","keywords":"","body":"Pyscan\n \nDatasheet\nThe datasheet of the Pyscan is available as a PDF File.\nPyscan Datasheet\nPyscan Libraries\n\nPyscan libraries to use the RFID/NFC reader are located here\nThe accelerometer library is here\n\nFor the time being, we recommend to upload the MFRC630.mpy file via FTP due to current limitations of Pymakr that will be fixed shortly.\n\nLibraries for the rest of the components will be added soon.\nPyscan components:\n\nAccelerometer: ST LIS2HH12\nAmbient light sensor: Lite-on LTR-329ALS-01\nRFID/NFC reader: NXP MFRC63002HN, 151\n\nDriver\nThe Windows 7 driver for Pyscan is located here.\nFor other Operating Systems there's no driver required.\nPinout\nThe pinout of the Pyscan is available as a PDF File\nPyscan Pinout\n\nBattery Charger\nThe board features a single cell Li-Ion/Li-Po charger. When the board is being powered via the micro USB connector, it will charge the battery (if connected).\n"},"datasheets/boards/expansion2.html":{"url":"datasheets/boards/expansion2.html","title":"Expansion Board 2.0","keywords":"","body":"Expansion Board 2.0\n \nDatasheet\nThe datasheet of the Expansion Board is available as a PDF File.\nExpansion Board 2 Datasheet\nPinout\nThe pinout of the Expansion Board is available as a PDF File\nExpansion Board 2 Pinout\n\nBe gentle when plugging/unplugging from the USB connector. Whilst the USB connector is soldered and is relatively strong, if it breaks off it can be very difficult to fix.\n\nBattery Charger\nThe Expansion Board features a single cell Li-Ion/Li-Po charger. When the board is being powered via the micro USB connector, the Expansion Board will charge the battery (if connected). When the CHG jumper is present the battery will be charged at 450mA. If this value is too high for your application, removing the jumper lowers the charge current to 100mA.\n"},"datasheets/boards/deepsleep/":{"url":"datasheets/boards/deepsleep/","title":"Deep Sleep Shield","keywords":"","body":"Deep Sleep Shield\nThe schematic of the Deep Sleep Shield is available as a PDF File.\nDeep Sleep Schematic\nPinout\nThe pinout of the Deep Sleep Shield is available as a PDF File\nDeep Sleep Pinout\n\nTo correctly connect a WiPy 2.0, LoPy or SiPy to the Deep Sleep Shield, align the white triangle on the Shield with the LED of the Pycom Device. Once the Pycom Device is seated onto the Deep Sleep Shield, this can then be connected to the Expansion Board\n\n\n"},"datasheets/boards/deepsleep/api.html":{"url":"datasheets/boards/deepsleep/api.html","title":"Deep Sleep API","keywords":"","body":"Deep Sleep API\nThis chapter describes the library which controls the Deep Sleep Shield. This includes the controls for external interrupts and timer setup of the deep sleep functionality.\nTo use this library, please upload the associated Deep Sleep Library to /lib on the target Pycom device.\nQuick Example\nfrom deepsleep import DeepSleep\nimport deepsleep\n\nds = DeepSleep()\n\n# get the wake reason and the value of the pins during wake up\nwake_s = ds.get_wake_status()\nprint(wake_s)\n\nif wake_s['wake'] == deepsleep.PIN_WAKE:\n print(\"Pin wake up\")\nelif wake_s['wake'] == deepsleep.TIMER_WAKE:\n print(\"Timer wake up\")\nelse: # deepsleep.POWER_ON_WAKE:\n print(\"Power ON reset\")\n\nds.enable_pullups('P17') # can also do ds.enable_pullups(['P17', 'P18'])\nds.enable_wake_on_fall('P17') # can also do ds.enable_wake_on_fall(['P17', 'P18'])\n\nds.go_to_sleep(60) # go to sleep for 60 seconds\n\nDeepSleep\nThe Deep Sleep Shield allows for waking up via a user trigger and also via an external interrupt (i.e. Accelerometer, Button).\nConstructors\nclass DeepSleep()\nCreates a DeepSleep object, that will control the board's sleep features. For example;\nds = DeepSleep()\n\nMethods\ndeepsleep.enable_auto_poweroff()\nThis method allows for a critical battery voltage to be set. For example, if the external power source (e.g. LiPo Cell) falls below 3.3V, turn off the Pycom device. This is intended to protect the hardware from under voltage.\ndeepsleep.enable_pullups(pins)\nThis method allows for pull-up pins to be enabled. For example, if an external trigger occurs, wake the Pycom device from Deep Sleep. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.disable_pullups(pins)\nThis method allows for pull-up pins to be disabled. For example, if an external trigger occurs, wake the Pycom device from Deep Sleep. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.enable_wake_on_raise(pins)\nThis method allows for pull-up pins to trigger on a rising voltage. For example, if an external rising voltage triggers occurs, wake the Pycom device from Deep Sleep. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.disable_wake_on_raise(pins)\nThis method allows for disabling pull-up pins that trigger on a rising voltage. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.enable_wake_on_fall(pins)\nThis method allows for pull-up pins to trigger on a falling voltage. For example, if an external falling voltage triggers occurs, wake the Pycom device from Deep Sleep. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.disable_wake_on_fall(pins)\nThis method allows for disabling pull-up pins that trigger on a falling voltage. pins may be passed into the method as a list, i.e. ['P17', 'P18'].\ndeepsleep.get_wake_status()\nThis method returns the status of the pins at wakeup from deep sleep. The method returns a dict with the states of wake, P10, P17, P18.\ndeepsleep.set_min_voltage_limit(value)\nThis method relates to the enable_auto_poweroff method and allows the user to specify the minimum power off voltage as a value.\ndeepsleep.go_to_sleep(seconds)\nThis method sends the board into deep sleep for a period of seconds or until an external interrupt has triggered (see set_pullups).\ndeepsleep.hw_reset()\nThis method resets the PIC controller and resets it to the state previous to the pins/min-voltage being set.\nPlease note that more functionality is being added weekly to these libraries. If a required feature is not available, feel free to contribute with a pull request at the Pycom Libraries GitHub repository.\n\n"},"datasheets/notes.html":{"url":"datasheets/notes.html","title":"Notes","keywords":"","body":"Notes\nPowering with an external power source\nThe devices can be powered by a battery or other external power source.\nBe sure to connect the positive lead of the power supply to VIN, and ground to GND.\nWhen powering via VIN:\n\nThe input voltage must be between 3.4V and 5.5V.\n\nPlease DO NOT power the board via the 3.3V pin as this may damage the device. ONLY use the VIN pin for powering Pycom devices.\n\nThe battery connector for the Expansion Board is a JST PHR-2 variant. The Expansion Board exposes the male connector and an external battery should use a female adapter in order to connect and power the expansion board. The polarity of the battery should be checked before being plugged into the expansion board, the cables may require swapping.\nThe GPIO pins of the modules are NOT 5V tolerant, connecting them to voltages higher than 3.3V might cause irreparable damage to the device.\n\nStatic electricity can damage components on the device and may destroy them. If there is a lot of static electricity in the area (e.g. dry and cold climates), take extra care not to shock the device. If the device came in a ESD bag (Silver packaging), the best way to store and carry the device is inside this bag as it will be protected against static discharges.\n\n"},"pybytes/introduction.html":{"url":"pybytes/introduction.html","title":"Introduction","keywords":"","body":"Introduction\n\nWhat is Pybytes?\nPybytes is an IoT Ecosystem that empowers you by granting full control of all your Pycom devices.\nWith Pybytes you have control over your device's data stream and more:\n\nVisualise sensors data according to your interests using our customisable dashboard;\nCheck the status of your entire fleet;\nKeep track of your assets with our geolocation feature;\nDistribute firmware updates on a scalable approach.\n\nIn a nutshell, Pybytes is an environment designed to optimise your IoT applications using Pycom boards.\nWhat Pybytes offers you?\n\nData Visualisation: Pybytes dashboard is customisable, allowing you to freely set up key performance indicators and time series data from all your sensors.\nIntelligent notifications: Keep track of your device's status, battery level, data streaming and measurements with pre-defined alarms. Receive notifications via email or SMS.\nTerminal: Execute commands to gather accurate information from your devices using Pybytes terminal shell.\nFirmware updates over the air: Upgrade or downgrade firmware versions with our exclusive firmware update.\nTrack your assets position: Google Maps API empowers your view over your device's geolocation.\n\nLet's get started!\n\nGetting started with Pybytes\nConnect your Pycom module to Pybytes\nVisualise data from your device\n​Integrations with external services​\n\n"},"pybytes/getstarted.html":{"url":"pybytes/getstarted.html","title":"Getting Started with Pybytes","keywords":"","body":"Getting Started with Pybytes\nFollow these steps to create a Pybytes account:\nStep 1: Go to the registration page\n\nGo to this link.\nEnter your full name, email address and a password to your account.\nConfirm the verification message sent to your email address.\nClick on the link and complete your login.\n\nGo Invent!\nNow it's time to explore Pybytes. You can start by connecting your Pycom board to Pybytes.\n"},"pybytes/connect/":{"url":"pybytes/connect/","title":"Add a device to Pybytes","keywords":"","body":"Add a device to Pybytes\nIn this section, we will explain to you how to add a device to Pybytes\nStep 1: Add device wizard\nIn Pybytes, go to Devices Page:\n\nClick on Add Device.\n\n\n\nSelect your device (e.g., WiPy, LoPy, SiPy, etc.);\n\n\n\nSelect your shield (e.g., PySense, PyTrack, PyScan or other);\n\n\n\nSelect your network option;\n\n\n\nEnter a unique name and the network credentials (SSID and password) for your device;\n\n\nStep 2: Connect your device to Pybytes\nAt the end of the \"Add Device\" wizard, Pybytes will give you two options for you to connect your device to Pybytes:\n\nSelect how you would like to connect your device to Pybytes:\n\nConnect your device quickly (Recommended)\n\n\nConnect your device by flashing Pybytes Library\n\nFrom firmware 1.16.x onwards all Pycom devices come with Pybytes library built-in /frozen folder. That means that you can choose between adding your device quickly with the firmware updater or you can flash Pybytes library manually.\n\n"},"pybytes/connect/quick.html":{"url":"pybytes/connect/quick.html","title":"Connect to Pybytes: Quick Add","keywords":"","body":"Connect to Pybytes: Quick Add\nConnecting a device to Pybytes quickly by using the Firmware Updater\nIn this section, we explain to you how to connect your device to Pybytes quickly using the Firmware Updater.\nIn case you want to extend Pybytes library you can flash Pybytes library manually. Click here for more information.\n\nStep 1: Download the firmware updater\nAt the last step of the \"Add Device\" process:\n\n\nDownload the firmware updater for your operating system;\n\n\n\nCopy the device token.\n\nStep 2: Firmware updater\nInstall the Firmware updater on your computer.\n\nStart the Firmware updater;\n\n\n\n\nSelect your device serial port (Make sure your device is connected to your computer);\n\nMark the options \"Erase flash file system\" and \"Force update Pybytes registration\";\n\n\n\n\nPaste your device token from Pybytes;\n\n\n\nThe firmware updater will update the device's firmware.\n\n\n\nNext step: Set up your device's dashboard!\nNow it's time to display data from your device into Pybytes dashboard.\n"},"pybytes/connect/flash.html":{"url":"pybytes/connect/flash.html","title":"Connect to Pybytes: Flash Pybytes library manually","keywords":"","body":"Connect to Pybytes: Flash Pybytes library manually\nConnecting a device to Pybytes by flashing Pybytes library manually\nIn this section, we will explain to you how to connect your device to Pybytes by flashing Pybytes library manually.\nFrom firmware 1.16.x onwards all Pycom devices come with Pybytes library build-in /frozen folder. That means that you can add your device quickly without the need of flashing Pybytes library manually. Click here for more information.\n\nStep 1: Download your Pybytes Library\nAt the last step of the \"Add Device\" process:\n\n\nClick on download \"Pybytes library\"\n\n\nYou can also download Pybytes library at the device's settings page:\n\nNavigate to your device in Pybytes;\n\nOn your device's page click on settings tab;\n\nClick on the button Download at Pybytes library;\n\n\n\nStep 2. Flash your device with Pymakr\nIn case you haven't installed Pymakr plugin, follow these instructions.\n\n\nConnect your device to your computer with USB cable.\nExtract download Pybytes library and open extracted folder with Atom.\nGet your device serial port: in Pymakr plugin click on More > get serial ports\nPaste your device's serial port to pymakr.conf file:\n {\n \"address\": \"PASTE_YOUR_SERIAL_PORT_HERE\",\n \"username\": \"micro\",\n \"password\": \"python\",\n \"sync_folder\": \"flash\"\n }\n\n\nCheckout your flash/pybytes_config.json file. It will be pre-filled with your information from Pybytes\nLike deviceToken or WiFi credentials. You can change e.g. your WiFy password here.\n\nPut your device in safe boot mode.\n\nUpload code to your device by clicking on Upload button in Pymakr.\nAfter all Pybytes library files are uploaded to device, device will restart and will connect to Pybytes.\n\n\nPybytes library is written to /flash folder and will take precedence over build in firmware libraries in /frozen folder.\n\nNext step: Set up your device's dashboard!\nNow it's time to display data from your device into Pybytes dashboard.\n"},"pybytes/connect/sigfox/":{"url":"pybytes/connect/sigfox/","title":"Add Sigfox device","keywords":"","body":"Add Sigfox device\nBefore you start you need to create Sigfox account. You need Pycom device with Sigfox to get your Sigfox account. Follow these instructions.\n\nCreate Sigfox API credentials\nOnce you have you account setup and are logged in Sigfox backend, you need to create API credentials for Pybytes.\nClick on GROUP → → API ACCESS → New\n\nIn the form chose arbitrary name, select Profiles DEVICE MANAGER [R] and DEVICE MANAGER [W]. Then click on Ok.\n\nCopy Login and Password to the clipboard.\n\nIn Pybytes go to Settings → Sigfox API or follow this link then paste in the form.\n\nSigfox contract types\nSigfox DevKit contracts\nRead more how to use Sigfox with devKit contract.\nSigfox custom contracts\nRead more how to use Sigfox with Custom contract.\n"},"pybytes/connect/sigfox/devkit.html":{"url":"pybytes/connect/sigfox/devkit.html","title":"DevKit contract","keywords":"","body":"DevKit contract\nEvery Sigfox Pycom device comes with free Sigfox connectivity - Sigfox DevKit contract. It provides one year of Sigfox connectivity. This is great for prototyping.\nBut every device you want to add to Pybytes you need register on Sigfox backend. You need to repeat Sigfox activation procedure.\nAfter you add your Sigfox credentials to Pybytes you can see DevKit contract type is selected as default (on page Settings → Sigfox API).\n\nAdd your device to Pybytes\n\nCreate Sigfox device (Lopy4, SiPy, FiPy) in Pybytes and copy its device token to clipboard.\nConnect your device to your computer and update it with Pycom firmware updater.\nSelect Pybytes firmware\nPaste your device token to firmware updater\n\n\n\nDetailed steps which are same for all devices are described here.\n\nCheck sigfox status\nGo to: Devices → → configuration\nNow you should see sigfox status component.\nClick on Check Sigfox status button\n\nYou should see two green lights.\nFirst green light means that your device was found in Sigfox group which uses Sigfox API credentials you saved to Pybytes.\nSecond green light means that HTTP POST callback was created on Sigfox backend for your Dev Kit device type. Because Dev Kit device type is associated with Dev Kit contract (which can hold only one device), you need to create Sigfox callback for every device you add to Pybytes.\nNote that Sigfox callback are associated to Sigfox device types.\nThis is not an issue with Custom contract, where device type on Sigfox backend can contain many devices, therefore you just need to one Sigfox HTTP POST callback (It is created automatically by Pybytes).\nTroubleshooting\nDisengage Sigfox sequence number\n"},"pybytes/connect/sigfox/custom.html":{"url":"pybytes/connect/sigfox/custom.html","title":"Custom contract","keywords":"","body":"Custom contract\nFor building Sigfox application on Pybytes we recommend to buy Sigfox contract.\nWith Sigfox custom contract you can use Pybytes to register Sigfox devices on Sigfox backend automatically (Pybytes talk to Sigfox backend API to register Sigfox devices automatically).\nYou can select Sigfox device type associated with your Sigfox custom contract.\nNewly created devices will be added to selected device type completely by Pybytes.\nAdding devices using Sigfox custom contract\nGo to: Settings (in sidebar) → Sigfox API → Settings\nand select Sigfox device type which is associated with Sigfox custom contract.\n\nAdd your Sigfox device to Pybytes\n\nCreate Sigfox device (Lopy4, SiPy, FiPy) in Pybytes and copy its device token to clipboard.\nConnect your device to your computer and update it with Pycom firmware updater.\nSelect Pybytes firmware\nPaste your device token to firmware updater\n\n\n\nDetailed steps which are same for all devices are described here.\n\nAfter your device was flashed with Pybytes firmware in automatically start adding itself to Sigfox backend.\n\nTroubleshooting\nDisengage Sigfox sequence number\n"},"pybytes/dashboard.html":{"url":"pybytes/dashboard.html","title":"Visualise data from your device","keywords":"","body":"Visualise data from your device\nIn this section, we will explain to you how to create widgets for data visualisation and set up your device's dashboard on Pybytes.\nWe assume that you already have your device connected to Pybytes. In case you haven't, check how to add your device here. After your done with that, you can proceed to the next example.\n\nStep 1: Set up your application (main.py)\nThe first step is to have an application running on your device. The application in this example sends data from a vector every 10 seconds to Pybytes.\n\nOpen the main.py file on Pymakr;\nInsert the following code on your main.py;\n\n# Import what is necessary to create a thread\nimport _thread\nfrom time import sleep\n\n# Increment index used to scan each point from vector sensors_data\ndef inc(index, vector):\n if index \n\nUpload the code into your device. Now your device is sending data to Pybytes.\n\nIn this code, we're calling the function pybytes.send_virtual_pin_value(persistent, pin, value)) to communicate with Pybytes. This function is part of the Pybytes library, and it has three arguments: persistent, pin and value.\n\npersistent denotes information that is infrequently accessed and not likely to be modified;\npin represents which virtual pin is receiving data;\nvalue is the value being attributed to that particular pin\n\n\nStep 2: Add a signal from your device\nGo to Pybytes.\n\nOn Devices page select a device;\n\n\n\nOn your device's page click on Data tab.\n\n\n\nClick on the Define New Signal button.\n\n\n\nDefine the new signal by entering a number, a name, a data type and a unit. Finally, click on the button Define.\n\n\n\nYour signal was added!\n\n\nThe name and unit are labels used to identify your signal inside Pybytes (In this example we defined Sinwave as the name of the signal and Rad as the unit).\nThe signal number has to match the pin number that you defined on pybytes.send_virtual_pin_value function call, inside your main.py code (In this example we defined pin = 1);\nThe datatype also has to match the variable used as argument on pybytes.send_virtual_pin_value function call, inside your main.py code (In this example our variable is a floating number; therefore we defined as a Float32).\n\nStep 3: Add a widget for the signal\n\nClick on the signal card.\n\n\n\nClick on the button Create a new display.\n\n\n\nSelect the type of visualisation (e.g. Bar chart or Line chart).\n\n\n\nYou can adjust the parameters of your widget at Settings. After, click on the button Create.\n\n\n\nYour widget was created. Now, add your widget to your device's dashboard. Click on the button Edit on your widget.\n\n\n\nMark the checkbox Display on Dashboard at Settings. Finally, click on the button Save.\n\n\n\nClick on the tab Dashboard. Your widget was successfully added there!\n\n\nStep 4: Organise your dashboard\n\nClick on the button Organise. Now the dashboard's grid will enter the edit mode and allow you to resize and reposition its widgets.\n\n\n\nResize a widget by clicking on the triangle icon at the bottom right corner of the widget and drag the cursor over the grid. After, click on the button Save to save this action.\n\n\n\nChange the widget's position by drag-and-dropping it over the grid. After, click on the button Save to save this action.\n\n\nDone!\nNow you've learned how to set up your device's dashboard to display data. Also, you can add more widgets to other pins of your device.\n"},"pybytes/integrations/":{"url":"pybytes/integrations/","title":"Integrations","keywords":"","body":"Integrations\nIntegration with external services \nPybytes offers a way to interact with external IoT platform or custom services, like the following:\n\n​AWS IoT: a managed cloud platform that lets connected devices easily and securely interact with cloud applications and other devices\n\n"},"pybytes/integrations/amazon-iot.html":{"url":"pybytes/integrations/amazon-iot.html","title":"Amazon IoT","keywords":"","body":"Amazon IoT\nWhenever one of your integrated devices sends a message to our broker, we republish the binary payload to the endpoint specified for its integration.\nIntegrate your devices \n\nGo in the sidebar, click on New Integration and then on Amazon Web Services\n\n\n\nFill in the form choosing an AWS region and your AWS credentials. You can optionally choose to save them inside the local storage for future use. Once you're done, click Login\n\n\n\nIn this step, you have to specify the AWS group name (just alphanumeric letter, dashes and underscore are allowed), the custom topic and the devices you want to bind to AWS. When you're ready, click Create\n\n\n\nIf everything's worked as expected, you should be able to see a summary of your integration like the following:\n\n\n\nThe corresponding AWS Thing and AWS Group has been created as well, you just have to log in to the console and choose the same region of your devices from the topbar. You'll be able to explore groups and things' details.\n\n\n\nThe device's name is specified as an attribute of the thing.\n\n\nFinal considerations \nIn order to save the data received by AWS, you must set up a rule. You can also test that everything's working with the AWS IoT MQTT client. Please notice that it's not possible to download the private key from AWS once it has been generated, by the way we securely store it inside our database. We may consider to allow its download in the future, so that you could also directly send your device to AWS, by passing Pybytes.\nWarning: do not delete AWS things or groups directly from AWS user interface, otherwise the integration with Pybytes will stop working. Always use Pybytes interface to delete AWS things or groups.\n"},"docnotes/introduction.html":{"url":"docnotes/introduction.html","title":"Introduction","keywords":"","body":"Introduction\nThe Pycom documentation aims to be straightforward and to adhere to typical Python documentation to allow for ease of understanding. However, there may be some unusual features for those not used to Python documentation or that are new to the MicroPython Language. This section of the documentation aims to provide clarity for any of the design specifics that might be confusing for those new to Python and this style of documentation.\n"},"docnotes/syntax.html":{"url":"docnotes/syntax.html","title":"Syntax","keywords":"","body":"Syntax\nThe Pycom documentation follows standard Python Library format using the popular Sphinx Docs tool. There are some notable points regarding the syntax of classes, methods and constants. Please see the notes below and familiarise yourself with the specific details before reviewing the documentation.\nKeyword Arguments\nKeyword Arguments refer to the arguments that are passed into a constructor (upon referencing a class object). When passing values into a MicroPython constructor it is not always required to specify the name of the argument and instead rely on the order of the arguments passed as to describe what they refer to. In the example below, it can be seen that the argument mode is passed into the i2c.init() method without specifying a name.\nThe values of the arguments (as seen in the examples/docs) refer to the default values that are passed into the constructor if nothing is provided.\ni2c.init(mode, * , baudrate=100000, pins=(SDA, SCL))\n\nAn example of how this method might be called:\ni2c.init(I2C.MASTER, pins=('P12', 'P11'))\n\nIt can be seen that a value for baudrate was not passed into the method and thus MicroPython will assume a default value of 100000. Also the first argument mode was not specified by name, as the constructor does not require it, denoted by the lack of an = symbol in the constructor documentation.\nPassing Arguments into a Method\nIt is important to note that there are certain class methods that can only accept a keyword for certain arguments as well as some that only accept a value. This is intentional by design but is not always apparent to the user calling specific methods. The differences between the two are outlined below, with examples referencing where differences might apply and what to be aware of.\nKeyword\nAn astrik * in a method description (in the docs), denotes that the following arguments require a keyword, i.e. pin='P16' in the example below.\nadc.channel(* , pin, attn=ADC.ATTN_0DB)\n\nfrom machine import ADC\n\nadc = ADC() # create an ADC object\napin = adc.channel(pin='P16') # create an analog pin on P16\n\npin is a required argument and the method channel will not execute unless it is passed as with a keyword.\nAnother example shows how the PWM class, pwm.channel() requires a keyword argument for pin but does not for id.\nfrom machine import PWM\n\npwm = PWM(0, frequency=5000)\npwm_c = pwm.channel(0, pin='P12') # no keyword argument requires for id (0) but is required for pin (pin='P12')\n\nValue\nThe documentation may refer to a method that takes an argument listed by name but does allow for a keyword to be passed. For example, the pycom class contains a method rgbled. This lists that the method accepts a value for color, however this may not be specified by keyword, only value. This is intentional as the value being passed is the only argument valid for this method\npycom.rgbled(color)\n\nIf the argument is passed into the method with a keyword, it will return an error stating TypeError: function does not take keyword arguments.\nimport pycom\n\npycom.rgbled(color=0xFF0000) # Incorrect\npycom.rgbled(0xFF0000) # Correct\n\nAnother example of a method that only accepts value input. In this case, the RTC.init() method require a value (tuple) input for the datetime. It will not accept a keyword.\nrtc.init(datetime)\n\nfrom machine import RTC\n\nrtc = RTC()\nrtc.init(datetime=(2014, 5, 1, 4, 13, 0, 0, 0)) # Incorrect\nrtc.init((2014, 5, 1, 4, 13, 0, 0, 0)) # Correct\n\nConstants\nThe constants section of a library within the docs refers to specific values from that library's class. These might be used when constructing an object from that class or when utilising a method from within that class. These are generally listed by the library name followed by the specific value. See the example below:\nI2C.MASTER()\n\nBe aware that you can only reference these constants upon importing and constructing a object from a library.\n\n"},"docnotes/replscript.html":{"url":"docnotes/replscript.html","title":"REPL vs Scripts","keywords":"","body":"REPL vs Scripts\nUsers of this documentation should be aware that examples given in the docs are under the expectation that they are being executed using the MicroPython REPL. This means that when certain functions are called, their output may not necessarily be printed to the console if they are run from a script. When using the REPL many classes/functions automatically produce a printed output displaying the return value of the function to the console. The code snippet below demonstrates some examples of classes/functions that might display this behaviour.\nBasic Arithmetic\n1 + 1 # REPL will print out '2' to console\n1 + 1 # Script will not return anything the console\nprint(1 + 1) # Both the REPL and a script will return '2' to the console\n\nCalling Methods\nimport ubinascii\n\nubinascii.hexlify(b'12345') # REPL will print out \"b'3132333435'\" to the console\nubinascii.hexlify(b'12345') # Script will not return any the console\n\nIn order to use these functions that do not print out any values, you will need to either wrap them in a print() statement or assign them to variables and call them later when you wish to use them.\nFor example:\n# immediately print to console when using a script\nprint(1 + 1)\n# or save variable to for later\nvalue = 1 + 1\n# do something here...\nprint(value)\n\n"},"docnotes/mesh-networks.html":{"url":"docnotes/mesh-networks.html","title":"Mesh Networks","keywords":"","body":"Mesh Networks\nMesh Networking is currently under development. Please click here for the documentation. Please keep in mind that this document is still only informational.\n"},"advance/downgrade.html":{"url":"advance/downgrade.html","title":"Firmware Downgrade","keywords":"","body":"Firmware Downgrade\nThe firmware upgrade tool usually updates your device to the latest available firmware version. If you require to downgrade your device to a previous firmware there are two methods to achieve this.\nIf you are using an Expansion Board 1.0 or 2.0, you will need to have a jumper connected between G23 and GND to use either procedure below. You will also need to press the reset button before beginning.\n\nYou can obtain previous firmware versions here:\n\nWiPy\nLoPy\nSiPy\nGPy\nFiPy\nLoPy4\n\nPrior to version 1.16.0.b1 the firmware for modules with LoRa functionality was frequency specific. From 1.16.0.b1 and onward, the firmware is region agnostic and this can either be set programatically or via the config block (see here).\n\nGUI\nAs of version 1.12.0.b0 of the firmware update tool, you can now provide a .tar or .tar.gz archive of the firmware you wish to upload to the board.\nWhen you start the update tool you will see the following screen:\n\nWhen you tick the Flash from local file option, an address bar will appear. Click the ... button and locate the .tar(.gz) file with the firmware you wish to flash to your device. From this point the updater will behave just like a regular update but using the local file instead of downloading the latest.\nCommand line\nYou can also use the CLI version of the update tool to downgrade your device. Will need to get a .tar or .tar.gz archive of the firmware you wish to upload to the board. Then run the following commands:\n$ pycom-fwtool-cli -v -p PORT flash -t /path/to/firmware/archive.tar.gz\n\n"},"advance/cli.html":{"url":"advance/cli.html","title":"CLI Updater","keywords":"","body":"CLI Updater\nCommand Line Update Utility\nWindows\nAfter installing the Windows version of the updater tool, the CLI tool pycom-fwtool-cli.exe can be found here:\n\n32-Bit Windows: C:\\Program Files\\Pycom\\Pycom Firmware Update\\\n64-Bit Windows: C:\\Program Files (x86)\\Pycom\\Pycom Firmware Update\\\n\nmacOS\nIn order to get access to the CLI tool on macOS, you will need to right click on the Mac version of the updater tool and click Show Package Contents, then navigate to Contents/Resources, here you will find the pycom-fwtool-cli.\nLinux\nIn the Ubuntu 14.04 LTS (and newer) version of the updater tool, pycom-fwtool-cli is installed in /usr/local/bin. In the Generic Linux package, the tool is extracted into folder ./pyupgrade\nUsage\nusage: pycom-fwtool-cli [-h] [-v] [-d] [-q] [-p PORT] [-s SPEED] [-c] [-x]\n [--ftdi] [--pic] [-r]\n {list,chip_id,wmac,smac,sigfox,exit,flash,copy,write,write_remote,wifi,pybytes,cb,nvs,ota,lpwan,erase_fs,erase_all}\n ...\n\nUpdate your Pycom device with the specified firmware image file For more\ndetails please see https://docs.pycom.io/chapter/advance/cli.html\n\npositional arguments:\n {list,chip_id,wmac,smac,sigfox,exit,flash,copy,write,write_remote,wifi,pybytes,cb,nvs,ota,lpwan,erase_fs,erase_all}\n list Get list of available COM ports\n chip_id Show ESP32 chip_id\n wmac Show WiFi MAC\n smac Show LPWAN MAC\n sigfox Show sigfox details\n exit Exit firmware update mode\n flash Write firmware image to flash\n copy Read/Write flash memory partition\n write Write to flash memory\n wifi Get/Set default WIFI parameters\n pybytes Read/Write pybytes configuration\n cb Read/Write config block\n nvs Read/Write non volatile storage\n ota Read/Write ota block\n lpwan Get/Set LPWAN parameters [ EU868 US915 AS923 AU915]\n erase_fs Erase flash file system area\n erase_all Erase entire flash!\n\noptional arguments:\n -h, --help show this help message and exit\n -v, --verbose show verbose output from esptool\n -d, --debug show debuggin output from fwtool\n -q, --quiet suppress success messages\n -p PORT, --port PORT the serial port to use\n -s SPEED, --speed SPEED\n baudrate\n -c, --continuation continue previous connection\n -x, --noexit do not exit firmware update mode\n --ftdi force running in ftdi mode\n --pic force running in pic mode\n -r, --reset use Espressif reset mode\n\nHow to use the Parameters\nThe CLI tool uses a combination of global and command specific parameters. The order of parameters is important to avoid ambiguity.\npycom-fwtool-cli [global parameters] [command] [command parameters]\nWhile pycom-fwtool-cli -h shows help for global parameters and a list of available commands, command specific parameters can be viewed using pycom-fwtool-cli [command] -h\nThe parameter -r, --reset has been added as a courtesy for users of 3rd party ESP32 products. This functionality is not supported by the Expansion Board 2.0 and may cause this tool to crash or hang in certain circumstances.\n\nGlobal Parameters\n`-h / --help` : shows above help (you can also get detailed help for each sub-command\n`-v / --verbose` : show verbose output from esptool.\n`-d / --debug` : show debug output from fwtool.\n`-q / --quiet` : suppress most output, used for scripting\n`-p / --port` : specifies the serial port to be used. Can also be set via **environment variable ESPPORT**\n`-s / --speed` : specifies the serial speed to be used. Can also be set via **environment variable ESPBAUD**\n`-c / --continuation` : continue previous connection in FTDI mode. This allows running multiple commands sequentially without having to reset the module. This option is ignored in PIC mode as the module can be reset via the serial connection.\n`-x / --noexit` : This will prevent the PIC from leaving firmware update mode.\n`--ftdi` : This will force the CLI updater to run in FTDI mode.\n`--pic` : This will force the CLI updater to run in PIC mode.\n`-r, --reset` : This will force the CLI updater to use Espressif's workaround to switch into Firmware update mode. This reset method is intended for 3rd party hardware only and is not supported by the Expansion Board 2.0\n\nCommands\nlist\nGet list of available serial ports ports.\nusage: pycom-fwtool-cli list [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nExample: On macOS:\n$ pycom-fwtool-cli list\n/dev/cu.usbmodemPy343431 [Pytrack] [USB VID:PID=04D8:F013 SER=Py343434 LOCATION=20-2]\n/dev/cu.Bluetooth-Incoming-Port [n/a] [n/a]\n\nOn Windows:\nCOM6 [Pytrack] [USB VID:PID=04D8:F013 SER=Py343434 LOCATION=20-2]\n\nThis is the only command that does not require any additional parameters.\nAll other commands require that the serial port is specified either through the -p / --port option or through environment variable ESPPORT You can optionally specify the speed either through -s / --speed or via environment variable ESPBAUD. The default speed is 921600. The maximum speed for read operations on PIC based expansion boards & shields is 230400. The speed will be reduced automatically if necessary.\nSpecial note for Expansion Board 2.0\nYou will need to have a jumper wire connected between G23 and GND to use any of the commands below. You will also need to press the reset button either before running each command or at least before running the first command. To avoid having to press the reset button again after each command, you can use the -c / --continuation option. The first command connecting to the device MUST NOT use the -c / --continuation option. This is to make sure a program called _stub_ is uploaded onto the device. This _stub_ cannot be uploaded more than once, so you need to tell the cli tool that the _stub_ is already running, which is done through using the -c / --continuation option.\n\nchip_id\nShows the unique ID of the ESP32 on the connected module.\nusage: pycom-fwtool-cli -p PORT exit [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nwmac\nShows the WiFi MAC of the connected module.\nusage: pycom-fwtool-cli -p PORT wmac [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nsmac\nShows the LPWAN MAC of the connected module.\nusage: pycom-fwtool-cli -p PORT smac [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nsigfox\nShow sigfox details\nusage: pycom-fwtool-cli -p PORT sigfox [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nexit\nIf a Pysense/Pytrack/Expansion 3 has previously been left in firmware update mode by using the -x option, this command can be used to exit the firmware update mode.\nusage: pycom-fwtool-cli -p PORT exit [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nflash\nWrites firmware image to flash, must be as a .tar(.gz) file as provided by Pycom. These files can be found on GitHub.\nusage: pycom-fwtool-cli -p PORT flash [-h] [-t TAR]\n\noptional arguments:\n -h, --help show this help message and exit\n -t TAR, --tar TAR perform the upgrade from a tar[.gz] file\n\ncopy\nRead/Write flash memory partition from/to local file\nusage: pycom-fwtool-cli -p PORT [-h] [-p PARTITION] [-f FILE] [-r] [-b]\n\noptional arguments:\n -h, --help show this help message and exit\n -p PARTITION, --partition PARTITION\n The partition to read/write (all, fs, nvs, factory,\n secureboot, bootloader, partitions, otadata, fs1,\n ota_0, config)\n -f FILE, --file FILE name of the binary file (default: -.bin)\n -r, --restore restore partition from binary file\n -b, --backup backup partition to binary file (default)\n\nwrite\nWrite to a specific location in flash memory.\nusage: pycom-fwtool-cli -p PORT write [-h] [-a ADDRESS] [--contents CONTENTS]\n\noptional arguments:\n -h, --help show this help message and exit\n -a ADDRESS, --address ADDRESS\n address to write to\n --contents CONTENTS contents of the memory to write (base64)\n\nwifi\nGet/Set default WiFi parameters.\nusage: pycom-fwtool-cli wifi [-h] [--ssid SSID] [--pwd PWD] [--wob [WOB]]\n\noptional arguments:\n -h, --help show this help message and exit\n --ssid SSID Set Wifi SSID\n --pwd PWD Set Wifi PWD\n --wob [WOB] Set Wifi on boot\n\npybytes\nRead/Write pybytes configuration.\nusage: pycom-fwtool-cli pybytes [-h] [--token TOKEN] [--mqtt MQTT] [--uid UID]\n [--nwprefs NWPREFS] [--extraprefs EXTRAPREFS]\n\noptional arguments:\n -h, --help show this help message and exit\n --token TOKEN Set Device Token\n --mqtt MQTT Set mqttServiceAddress\n --uid UID Set userId\n --nwprefs NWPREFS Set network preferences\n --extraprefs EXTRAPREFS\n Set extra preferences\n\nNote: The local pybytes_config.json file is overwritten when making any modifications using this command (requires Pybytes firmware 1.17.5.b6 or higher and Firmware updater 1.14.3).\n\ncb\nRead/Write config block (LPMAC, Sigfox PAC & ID, etc.). You can find the structure of this block here.\nusage: pycom-fwtool-cli -p PORT cb [-h] [-f FILE] [-b] [-r]\n\noptional arguments:\n -h, --help show this help message and exit\n -f FILE, --file FILE name of the backup file\n -b, --backup backup cb partition to file\n -r, --restore restore cb partition from file\n\nIf neither -b or -r is provided, the command will default to backup. If no file name is provided, .cb is used.\nTo backup your config block: $pycom-fwtool-cli -p PORT cb\nTo restore your config block: $pycom-fwtool-cli -p PORT cb -r -f backup.cb\nnvs\nRead/Write non-volatile storage.\nusage: pycom-fwtool-cli -p PORT nvs [-h] [-f FILE] [-b] [-r]\n\noptional arguments:\n -h, --help show this help message and exit\n -f FILE, --file FILE name of the backup file\n -b, --backup backup cb partition to file\n -r, --restore restore cb partition from file\n\nIf neither -b or -r is provided, the command will default to backup. If no file name is provided, .nvs is used.\nTo backup your NVS: $ pycom-fwtool-cli -p PORT nvs\nTo restore your NVS: $ pycom-fwtool-cli -p PORT nvs -r -f backup.nvs\nota\nRead/Write ota block, this contains data relating to OTA updates such as the hash of the OTA firmware.\nusage: pycom-fwtool-cli ota [-h] [-f FILE] [-b] [-r]\n\noptional arguments:\n -h, --help show this help message and exit\n -f FILE, --file FILE name of the backup file\n -b, --backup backup cb partition to file\n -r, --restore restore cb partition from file\n\nIf neither -b nor -r is provided, the command will default to backup. If no file name is provided, .ota is used.\nTo backup your OTA block: $pycom-fwtool-cli -p PORT ota\nTo restore your OTA block: $pycom-fwtool-cli -p PORT ota -r -f backup.ota\nlpwan\nGet/Set LPWAN parameters saved to non-volatile storage. Please see here for more details.\nusage: pycom-fwtool-cli -p PORT lpwan [-h] [--region REGION]\n\noptional arguments:\n -h, --help show this help message and exit\n --region REGION Set default LORA region\n --erase_region Erase default LORA region\n --lora_region Output only LORA region\n\nerase_fs\nErase flash file system area. This is useful if some code running on the device is preventing access to the REPL.\nusage: pycom-fwtool-cli -p PORT erase_fs [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\nerase_all\nErase entire flash, only use this if you are sure you know what you are doing. This will remove your devices lpwan mac addresses etc.\nusage: pycom-fwtool-cli erase_all [-h]\n\noptional arguments:\n -h, --help show this help message and exit\n\n"},"advance/encryption.html":{"url":"advance/encryption.html","title":"SecureBoot and Encryption","keywords":"","body":"SecureBoot and Encryption\nSummary\nIn order to encrypt your firmware, you will need to build it from source. Our firmware source code can be found here, along with instructions on how to build it. Below you will find specific instructions on how generate keys, build and flash encrypted firmware.\n\nObtain keys (for Secure Boot and Flash Encryption)\nFlash keys and parameters in efuses\nCompile bootloader and application with make SECURE=on\nFlash: bootloader-digest at address 0x0 and encrypted; all the others (partitions and application) encrypted, too.\n\nPrerequisites\nFirstly you will need to setup the tool chain and download the source code. detailed instructions on how to achieve this can be found here. Once you have complete this, you will need to open a terminal in the esp32 folder of the firmware source code repo.\nNext you will need keys for Flash Encryption and Secure Boot; they can be generated randomly with the following commands:\npython $IDF_PATH/components/esptool_py/esptool/espsecure.py generate_flash_encryption_key flash_encryption_key.bin\npython $IDF_PATH/components/esptool_py/esptool/espsecure.py generate_signing_key secure_boot_signing_key.pem\n\nThe Secure Boot key secure_boot_signing_key.pem has to be transformed into secure-bootloader-key.bin, to be burnt into efuses. This can be done in 2 ways:\npython $IDF_PATH/components/esptool_py/esptool/espsecure.py extract_public_key --keyfile secure_boot_signing_key.pem signature_verification_key.bin\n\nor, as an artifact of the make build process, on the same directory level as Makefile\nmake BOARD=GPY SECURE=on TARGET=boot\n\nTo flash the keys (flash_encryption_key.bin and secure-bootloader-key.bin) into the efuses (write and read protected) run the following commands (ignoring the lines that start with #):\nNote: Irreversible operations\n# Burning Encryption Key\npython $IDF_PATH/components/esptool_py/esptool/espefuse.py --port /dev/ttyUSB0 burn_key flash_encryption flash_encryption_key.bin\n# Burning Secure Boot Key\npython $IDF_PATH/components/esptool_py/esptool/espefuse.py --port /dev/ttyUSB0 burn_key secure_boot secure-bootloader-key.bin\n# Enabling Flash Encryption mechanism\npython $IDF_PATH/components/esptool_py/esptool/espefuse.py --port /dev/ttyUSB0 burn_efuse FLASH_CRYPT_CNT\n# Configuring Flash Encryption to use all address bits together with Encryption key (max value 0x0F)\npython $IDF_PATH/components/esptool_py/esptool/espefuse.py --port /dev/ttyUSB0 burn_efuse FLASH_CRYPT_CONFIG 0x0F\n# Enabling Secure Boot mechanism\npython $IDF_PATH/components/esptool_py/esptool/espefuse.py --port /dev/ttyUSB0 burn_efuse ABS_DONE_0\n\nIf the keys are not written in efuse, before flashing the bootloader, then random keys will be generated by the ESP32, they can never be read nor re-written, so bootloader can never be updated. Even more, the application can be re-flashed (by USB) just 3 more times.\nMakefile options\nmake BOARD=GPY SECURE=on SECURE_KEY=secure_boot_signing_key.pem ENCRYPT_KEY=flash_encryption_key.bin TARGET=[boot|app]\n\n\nSECURE=on is the main flag; it's not optional\nif SECURE=on the following defaults are set:\nencryption is enable \nsecure_boot_signing_key.pem is the secure boot key, located relatively to Makefile\nflash_encryption_key.bin is the flash encryption key, located relatively to Makefile\n\n\n\nFor flashing the bootloader digest and the encrypted versions of all binaries:\nmake BOARD=GPY SECURE=on flash\n\nFlashing\nFor flashing the bootloader-reflash-digest.bin has to be written at address 0x0, instead of the bootloader.bin (at address 0x1000).\nBuild is done using SECURE=on option; additionally, all the binaries are pre-encrypted.\nmake BOARD=GPY clean\nmake BOARD=GPY SECURE=on TARGET=boot\nmake BOARD=GPY SECURE=on TARGET=app\nmake BOARD=GPY SECURE=on flash\n\nManual flash command:\npython $IDF_PATH/components/esptool_py/esptool/esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 921600 --before no_reset --after no_reset write_flash -z --flash_mode dio --flash_freq 80m --flash_size detect 0x0 build/GPY/release/bootloader/bootloader-reflash-digest.bin_enc 0x8000 build/GPY/release/lib/partitions.bin_enc 0x10000 build/GPY/release/gpy.bin_enc_0x10000\n\nOTA update\nThe OTA should be done using the pre-encrypted application image.\nBecause the encryption is done based on the physical flash address, there are 2 application binaries generated:\n\ngpy.bin_enc_0x10000 which has to be written at default factory address: 0x10000\ngpy.bin_enc_0x1A0000 which has to be written at the ota_0 partition address (0x1A0000)\n\nHint: on MicroPython interface, the method pycom.ota_slot() responds with the address of the next OTA partition available (either 0x10000 or 0x1A0000).\n\n"},"documents/certificates.html":{"url":"documents/certificates.html","title":"Certificates","keywords":"","body":"Certificates\nCE RED\nDevelopment Boards\nLoPy\nLoPy CE RED Certificate\nWiPy 2.0\nWiPy 2.0 CE RED Certificate\"\nWiPy 3.0\nWiPy 3.0 CE RED Certificate\nSiPy\nSiPy CE RED Certificate\nGPy\nGPy CE RED Certificate.pdf)\nFiPy\nFiPy CE RED Certificate\nOEM Modules\nL01\nL01 CE RED Certificate\nW01\nW01 CE RED Certificate\nG01\nG01 CE RED Certificate\nFCC\nDevelopment Boards\nLoPy\nLoPy FCC Certificate\nLoPy FCC Certificate\nLoPy FCC Certificate\nWiPy 2.0\nWiPy 2.0 FCC Certificate\nWiPy 2.0 FCC Certificate\nGPy\nGPy FCC Certificate\nGPy FCC Certificate\nGPy FCC Certificate\nFiPy\nFiPy FCC Certificate\nFiPy FCC Certificate\nFiPy FCC Certificate\nFiPy FCC Certificate\nOEM Modules\nL01\nL01 FCC Certificate\nL01 FCC Certificate\nL01 FCC Certificate\nW01\nW01 FCC Certificate\nW01 FCC Certificate\nG01\nG01 FCC Certificate\nG01 FCC Certificate\nG01 FCC Certificate\n"},"documents/license.html":{"url":"documents/license.html","title":"License","keywords":"","body":"License\nThe MIT License (MIT)\nCopyright (c) 2013-2015 Damien P. George, and others\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\nTHE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\nCopyright (c) 2017, Pycom Limited.\nThis software is licensed under the GNU GPL version 3 or any later version, with permitted additional terms. For more information see the Pycom Licence v1.0 document supplied with this file, or available at https://www.pycom.io/opensource/licensing\n"}}} \ No newline at end of file